Question

我目前正在开发基于GPS的项目，我目前正在使用凌空从网络接收数据，但最近他们计划使用实时数据升级服务。因此，Web开发人员使用websocket对服务器进行了编程，对于浏览器应用程序，他们说，他们使用stomp.js协议从服务器检索数据。他们要求我从他们的服务器（实时数据）中检索数据，但我不知道什么是从websocket获取实时数据的最佳方法。我从github https://github.com/NaikSoftware/StompProtocolAndroid找到了一个例子，但这对我来说还不够学习，在互联网上使用stomp的文档是不够的。我希望在android中有更好的实现。

如有任何帮助和建议，将不胜感激。请不要提及我的firebase，因为我已经提到过firebase，他们拒绝使用它。请伙计们帮助我，建议我或者给我一个很好的例子来简单地使用排球从websocket服务器检索数据。

Answer 1

我的回答是基于这个问题的评论。没有关于这个问题的足够信息，所以我正在为您的问题编写2个解决方案

解决方案1 - 不使用Stomp Implementation- Simple websocket

这是一个简单的Websocket实现。为此，您可以使用koush/AndroidAsync库

将此项目实施到您的项目中

    dependencies {
    compile 'com.koushikdutta.async:androidasync:2.+'
}

然后连接到Websocket服务器

 String url="ws://172.17.1.54:8000/";
    AsyncHttpClient.getDefaultInstance().websocket(url, "my-protocol", new WebSocketConnectCallback() {
        @Override
        public void onCompleted(Exception ex, WebSocket webSocket) {
            if (ex != null) {
                ex.printStackTrace();
                return;
            }

            webSocket.setStringCallback(new StringCallback() {
                public void onStringAvailable(String s) {
                    System.out.println("I got a string: " + s);
                }
            });
            webSocket.setDataCallback(new DataCallback() {
                public void onDataAvailable(DataEmitter emitter, ByteBufferList byteBufferList) {
                    System.out.println("I got some bytes!");
                    // note that this data has been read
                    byteBufferList.recycle();
                }
            });
        }
    });

这里的setStringCallback（）＆amp; setDataCallback（）将收到您的实时更新。

您也可以使用codebutler/android-websockets库。

解决方案2：使用Stomp实现

为此，您可以使用Gozirra java库来解决此问题。您可以download客户端库。然后将其放入libs文件夹。

用于连接服务器

 Client c = new Client("server url", port, "login", "password");

为更新创建一个监听器

 Listener listener=new Listener() {
            @Override
            public void message(Map map, String s) {
                //Do your stuff
            }
        };

然后订阅您的主题消息

 c.subscribe("foo-channel", listener);

如果您想取消订阅，可以使用以下代码

  c.unsubscribe("foo-channel", listener);  // Unsubscribe only one listener

或

 c.unsubscribe("foo-channel");   // Unsubscribe all listeners

断开客户端

c.disconnect();

我没有使用真正的服务器对此进行测试。但我认为这样可行。请告诉我是否能解决您的问题

解决方案3

当你提到图书馆https://github.com/NaikSoftware/StompProtocolAndroid时你可以用它。简化版本如下

将maven链接添加到项目级别gradle

  repositories {
        maven { url "https://jitpack.io" }
    }

在模块级gradle中添加依赖项

 implementation 'com.github.NaikSoftware:StompProtocolAndroid:1.1.5'
 implementation 'org.java-websocket:Java-WebSocket:1.3.0'

然后使用以下代码获取消息

 StompClient mStompClient = Stomp.over(WebSocket.class, "ws://10.0.2.2:5000/");


    mStompClient.topic("/topic/general").subscribe(new Action1<StompMessage>() {
        @Override
        public void call(StompMessage stompMessage) {
            Log.e(TAG, stompMessage.getPayload());
        }
    });
    mStompClient.lifecycle().subscribe(new Action1<LifecycleEvent>() {
        @Override
        public void call(LifecycleEvent lifecycleEvent) {
            switch (lifecycleEvent.getType()) {

                case OPENED:
                    Log.e(TAG, "Stomp connection opened");
                    break;

                case ERROR:
                    Log.e(TAG, "Error", lifecycleEvent.getException());
                    break;

                case CLOSED:
                    Log.e(TAG, "Stomp connection closed");
                    break;
            }
        }
    });
    mStompClient.connect();

Answer 2

使用Square的OkHttp库。

将此依赖项添加到构建gradle

implementation 'com.squareup.okhttp3:okhttp:3.10.0'

使用以下课程来收听webshockts

public class SocketListner extends WebSocketListener {

    private Mediator mediator;

    private static final int CLOSURE_STATUS = 1000;
    private WebSocket webSocket = null;

    public SocketListner(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void onOpen(WebSocket webSocket, Response response) {
        super.onOpen(webSocket, response);
        this.webSocket = webSocket;
        mediator.onConnected(webSocket, response);
    }

    public void sendMsg(String msg) {
        if (webSocket != null)
            webSocket.send(msg);
    }

    @Override
    public void onFailure(WebSocket webSocket, Throwable t, @Nullable Response response) {
        mediator.onFailure(webSocket, t.getLocalizedMessage());
        AppCons.printTag("Failure :", t.getMessage());
    }

    @Override
    public void onClosed(WebSocket webSocket, int code, String reason) {
        mediator.closingOrClosed(true, webSocket, reason, code);
        AppCons.printTag("Closed :", reason);
    }

    @Override
    public void onClosing(WebSocket webSocket, int code, String reason) {
        mediator.closingOrClosed(false, webSocket, reason, code);
        AppCons.printTag("Closing :", reason);
    }

    @Override
    public void onMessage(WebSocket webSocket, String text) {
        mediator.getMessage(text);
    }

    public interface Mediator {
        void onConnected(WebSocket webSocket, Response response);

        void getMessage(String msg);

        void onFailure(WebSocket webSocket, String reason);

        void closingOrClosed(boolean isClosed, WebSocket webSocket, String reason, int code);

    }

    public WebSocket getWebSocket() {
        return webSocket;
    }
}

使用以下代码通过shocket

访问数据

private OkHttpClient client;
private SocketListner listner;
private void startShocketConnection() {


    client = new OkHttpClient.Builder().readTimeout(3, TimeUnit.SECONDS).build();

    listner = new SocketListner(new SocketListner.Mediator() {
        @Override
        public void onConnected(WebSocket webSocket, Response response) {
            Log.d("Connected :", response.toString());
        }

        @Override
        public void getMessage(String msg) {
            try {
                Log.d("Received", msg);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onFailure(WebSocket webSocket, String reason) {
            //reconnect when failure with server
            Log.d("Failure :", reason);
        }

        @Override
        public void closingOrClosed(boolean isClosed, WebSocket webSocket, String reason, int code) {
            Log.d("ClosingOrClosed :", isClosed ? "Closed" : "closing");
        }
    });

    Request request = new Request.Builder()
            .url("your shocket url")
            .build();
    client.newWebSocket(request, listner);

}

private void closeSocket() {

        try {
            listner.getWebSocket().cancel();
            listner.getWebSocket().close(1000, "Good bye !");

            if ((response != null)) {
                client.dispatcher().executorService().shutdown();
                client.connectionPool().evictAll();
                response.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        response = null;
    }

建议我从websocket服务器

2 个答案: