websocket框架socket-io-java使用小结

目录
- 序言
- 准备工作
  - 如何导入socket-io-java 框架
- socket-io的基本用法.
  - 打印socket-io中的log信息
- socket-io源码解析
  - connect()里的都干了什么.
- 关于websocket的一些技术文档和文章

序言

WebSocket 协议是伴随HTML5发布的一种新协议,它实现了服务端到客户端浏览器之间的全双工通信.WebSocket常使用于IM通信等场景.当然由于其全双工的特性,也同样适用于直播弹幕这种场景.

WebSocket 大概有以下特点:

基于socket实现保证了消息通信的实时性.
提供文本和二进制数据两种格式的数据传输.
在建立连接时使用http协议,连接过程中使用ws/wss协议通信.ws占用http请求的80端口,wss占用https请求的443端口.建立连接后,websocket没有规定具体协议,需要使用者自行进行扩展.

如何导入 socket-io-java框架

WebSocket协议是伴随Html5协议发布的,最初它应该是为浏览器程序与web服务器间通信而设计的一种协议.socket-io-java是 socket.io 在java平台的客户端实现,而服务端实现则有配套的 socket-io-netty。

Eclipse下导入 socket-io jar

Android Studio 环境下导入socket-io 非常轻松方便,只需要在gradle文件中添加依赖,直接参阅 socket-io 的官方文档即可.
而某些同学和我一样,因为种种原因在eclipse下开发,就需要导入jar包了.
这里总结下我在导入jar包时遇到的坑:

除了 socket-io-client 这个jar包之外,我们还需要导入一个 engine-io-socket 的包. client包中主要包含了客户端操作websocket的api,而engine包中包含了socket-io的核心实现.

Socket-io库中的网络实现使用OkHttp实现.如果你的项目之前没有使用 OkHttp,那么你还需要额外导入 OkHttp相关的jar包.需要注意的是 okhttp-ws 这个jar包,我在maven上找到的最高版本是3.4.1.而它需要配合3.4.1版本的okhttp使用.在高版本的okhttp jar包中(例如3.8版本),是默认包括了对WebSocket的支持的,但由于我使用的是 0.8.2版本的 socket-io-java，导致与3.8版本的okhttp不兼容.所以在导入jar包时需要注意版本的问题.

image.png

socke-io的基本用法

socket = IO.socket("http://localhost");
socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {

  @Override
  public void call(Object... args) {
    socket.emit("foo", "hi");
    socket.disconnect();
  }

}).on("event", new Emitter.Listener() {

  @Override
  public void call(Object... args) {}

}).on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {

  @Override
  public void call(Object... args) {}

});
socket.connect();

官方文档中已经给出 socket-io的基本用法了. socket-io的api非常的简洁,基本只需要初始,化注册回调,连接三步就搞定了.

打印socket-io中的log信息

socket-io对外暴露的api实在太少了,不像 rxjava 等一些框架海量的函数,所以用起来非常方便简单.但是同样也造成一个问题，框架的封装程度越高，我们就越难获取到框架中流程的信息.而 socket-io 这个框架连基本的日志信息都隐藏掉了,如果想要详细了解内部信息，这样是很不利的:

 public Manager open(final OpenCallback fn) {
        EventThread.exec(new Runnable() {
            @Override
            public void run() {
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine(String.format("readyState %s", Manager.this.readyState));
                }

可以看到框架中的日志使用的是java里的logger这个类来打印基本日志,但是这些日志级别太低,java中默认打印debug以上级别的日志.
获取的日志的思路就是要改变logger的日志级别,准确的说是日志的输出级别.
java中logger输出的日志级别由两个因素决定:一个是logger中通过 setLevel() 函数设定的日志打印级别,用来决定日志中哪些日志会被输出到输出流中.还有一个就是Handler中设定的日志输出级别,logger负责输出日志到具体的某个Handler中，例如 FiledHandler,ConsoleHandler,handler中设定的level决定哪些日志是最终会输出到文件或者console中.

private void changeLoggerLevel() {
        // init a new logger with level FINE
        Logger logger = Logger.getLogger(Socket.class.getName());
        logger.setLevel(Level.FINE);
        Handler consoleHandler = new ConsoleHandler();
        consoleHandler.setLevel(Level.ALL);
        logger.addHandler(consoleHandler);

        ArrayList loggerName = new ArrayList();
        int i = IO.protocol;
        String j = Socket.EVENT_CONNECT;
        String k = Manager.EVENT_CLOSE;
        try {
            Manager manager = Manager.class.newInstance();
            WebSocket webSocket = new WebSocket(new Options());
            EventThread.exec(new Runnable() {
                @Override
                public void run() {
                }
            });
            PollingXHR pollingXHR = new PollingXHR(
                    new io.socket.engineio.client.Transport.Options());
            io.socket.engineio.client.Socket socket = new io.socket.engineio.client.Socket();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        String m = PollingXHR.EVENT_REQUEST_HEADERS;
        String n = WebSocket.EVENT_DRAIN;
        loggerName.add(IO.class.getName());
        loggerName.add(Socket.class.getName());
        loggerName.add(Manager.class.getName());
        loggerName.add(PollingXHR.class.getName());
        loggerName.add(WebSocket.class.getName());
        loggerName.add(io.socket.engineio.client.Socket.class.getName());
        loggerName.add(Parser.class.getName());
        for (String tag : loggerName) {
            Logger temp = LogManager.getLogManager().getLogger(tag);
            if (temp != null) {
                temp.setLevel(Level.ALL);
                temp.addHandler(consoleHandler);
            } else {
                LogUtil.debugLog(LEVEL.ERROR, TAG, temp + "=null", true);
            }
        }
    }

清楚了原理，我们就可以来动手写具体的代码了:通过反射获取你需要日志信息的类中logger的实例,使用setLevel()函数将日志过滤等级调整为FINE级别以下，然后再为其添加相同等级的ConsoleHandler对象,在 logcat 中查看TAG为system.err()的日志,就能查看到socket-io框架内部输出的信息了.如果没有修改logger中handler的级别,即使修改logger的全局打印级别也是没用的.

image.png

打印出来的信息大概就是这样的，其中有非常详细的建立连接,升级协议，发送和接受message等等信息,通过这些信息结合源代码可以对整个流程进行研究.

socket-io源码的一点解析

socket-io的整个流程并不复杂。首先客户端会发送http请求来与服务端建立连接,接着发送一个http请求请求升级为 ws协议，如果服务端返回101就是表示切换协议成功,此时客户端就与服务端建立了socket长连接,而后客户端与服务端会不停地发送 ping包和 pong包来确认连接没有断开.

connect()函数里都干了什么.

    /**
     * Connects the socket.
     */
    public Socket open() {
        EventThread.exec(new Runnable() {
            @Override
            public void run() {
                if (Socket.this.connected) return;

                Socket.this.subEvents();
                Socket.this.io.open(); // ensure open
                if (Manager.ReadyState.OPEN == Socket.this.io.readyState) Socket.this.onopen();
                Socket.this.emit(EVENT_CONNECTING);
            }
        });
        return this;
    }

调用 socket-io的 connect()函数会直接转入 open()函数.这里首先会调用subEvents()函数为 Manager对象添加回调监听 EVENT_OPEN,EVENT_PACKET,EVENT_CLOSE这三个事件.

 final Manager io = Socket.this.io;
        Socket.this.subs = new LinkedList() {{
            add(On.on(io, Manager.EVENT_OPEN, new Listener() {
                @Override
                public void call(Object... args) {
                    Socket.this.onopen();
                }
            }));
            add(On.on(io, Manager.EVENT_PACKET, new Listener() {
                @Override
                public void call(Object... args) {
                    Socket.this.onpacket((Packet) args[0]);
                }
            }));
            add(On.on(io, Manager.EVENT_CLOSE, new Listener() {
                @Override
                public void call(Object... args) {
                    Socket.this.onclose(args.length > 0 ? (String) args[0] : null);
                }
            }));

接着会调用 Manager中的open()函数,接着会调用到 engine.io.Socket中的 open 函数.

 Manager.this.engine.open();

在open()函数中会判断是否发起 WebSocket 连接.最后调用transport.open()向服务器发起连接.

                if (Socket.this.rememberUpgrade && Socket.priorWebsocketSuccess && Socket.this.transports.contains(WebSocket.NAME)) {
                    transportName = WebSocket.NAME;
                } 

.....

transport.open();

具体的连接细节比较繁琐，暂不展开，后面再补充.

关于websocket的一些技术文档和文章

socket-io的github地址: https://github.com/socketio/socket.io-client-java
engine-io的github地址: https://github.com/socketio/engine.io-client-java
腾讯bugly的文章: http://blog.csdn.net/tencent_bugly/article/details/60580396
一篇介绍okhttp实现websocket的文章: http://blog.csdn.net/sbsujjbcy/article/details/52839540