如何在Android应用中接入基于Spring Boot的STOMP WebSocket后端？

Nice work getting your Spring Boot STOMP backend up and running! Connecting your Android app to it is totally doable with a solid STOMP client library and some straightforward setup. Let me walk you through the steps:

1. Add Required Dependencies #

First, add a STOMP client library to your app-level build.gradle (or build.gradle.kts). A popular, reliable choice is StompProtocolAndroid—it supports SockJS fallback, which aligns perfectly with your backend's configuration. We'll also add Gson for JSON serialization (to handle your Message and MessageResponse objects):

dependencies {
    // STOMP client with SockJS support
    implementation 'com.github.NaikSoftware:StompProtocolAndroid:2.0.7'
    // JSON serialization/deserialization
    implementation 'com.google.code.gson:gson:2.10.1'
}

2. Mirror Backend Model Classes #

Create Android versions of your backend's Message and MessageResponse models. These will let you easily convert between Java objects and JSON for sending/receiving data:

// Message.java
public class Message {
    private String text;
    private String username;

    // Empty constructor is required for Gson deserialization
    public Message() {}

    public Message(String text, String username) {
        this.text = text;
        this.username = username;
    }

    // Getters and setters
    public String getText() { return text; }
    public void setText(String text) { this.text = text; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
}

// MessageResponse.java
public class MessageResponse {
    private String text;
    private String username;

    public MessageResponse() {}

    public MessageResponse(String text, String username) {
        this.text = text;
        this.username = username;
    }

    // Getters and setters
    public String getText() { return text; }
    public void setText(String text) { this.text = text; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
}

3. Implement STOMP Connection & Message Logic #

Create a helper class to manage the STOMP connection, subscriptions, and message sending. This keeps your code organized and reusable across your app:

import android.os.Looper;
import android.util.Log;
import com.google.gson.Gson;
import ua.naiksoftware.stomp.Stomp;
import ua.naiksoftware.stomp.StompClient;
import ua.naiksoftware.stomp.dto.LifecycleEvent;
import ua.naiksoftware.stomp.dto.StompMessage;

public class StompChatManager {
    private static final String TAG = "StompChatManager";
    private StompClient mStompClient;
    private final Gson mGson = new Gson();
    // Replace with your backend's actual URL: use your computer's local IP (not localhost) for testing
    private static final String BACKEND_WS_URL = "ws://192.168.1.100:8080/chatsocket";
    // Use this URL for SockJS fallback if WebSockets are blocked:
    // private static final String BACKEND_SOCKJS_URL = "http://192.168.1.100:8080/chatsocket/websocket";

    // Initialize and establish connection to backend
    public void connectToBackend() {
        // Initialize Stomp client with OKHTTP provider
        mStompClient = Stomp.over(Stomp.ConnectionProvider.OKHTTP, BACKEND_WS_URL);

        // Listen for connection lifecycle events
        mStompClient.lifecycle()
                .subscribe(this::handleLifecycleEvent);

        // Start connection
        mStompClient.connect();
    }

    private void handleLifecycleEvent(LifecycleEvent event) {
        switch (event.getType()) {
            case OPENED:
                Log.d(TAG, "STOMP connection opened!");
                // Once connected, subscribe to your target topic (e.g., "chatroom1")
                subscribeToTopic("chatroom1");
                break;
            case ERROR:
                Log.e(TAG, "STOMP connection error", event.getException());
                // Handle error (e.g., show toast to user)
                break;
            case CLOSED:
                Log.d(TAG, "STOMP connection closed");
                // Optional: Add reconnection logic here for production apps
                break;
        }
    }

    // Subscribe to a topic to receive incoming messages
    private void subscribeToTopic(String topicName) {
        String destination = "/topic/" + topicName;
        mStompClient.topic(destination)
                .subscribe(this::handleIncomingMessage);
    }

    private void handleIncomingMessage(StompMessage message) {
        // Parse JSON payload to MessageResponse object
        MessageResponse response = mGson.fromJson(message.getPayload(), MessageResponse.class);
        
        // Update UI on the main thread (critical for Android!)
        new android.os.Handler(Looper.getMainLooper()).post(() -> {
            // Example: Update your chat UI with the new message
            Log.d(TAG, String.format("Received message from %s: %s", response.getUsername(), response.getText()));
            // Replace with your UI update logic (e.g., add to RecyclerView adapter)
        });
    }

    // Send a message to the backend
    public void sendMessageToTopic(String topicName, String username, String messageText) {
        String destination = "/app/msg/" + topicName;
        Message message = new Message(messageText, username);
        String messageJson = mGson.toJson(message);
        
        mStompClient.send(destination, messageJson)
                .subscribe(
                        () -> Log.d(TAG, "Message sent successfully"),
                        error -> Log.e(TAG, "Failed to send message", error)
                );
    }

    // Disconnect when the app is paused or destroyed
    public void disconnectFromBackend() {
        if (mStompClient != null) {
            mStompClient.disconnect();
            Log.d(TAG, "STOMP connection disconnected");
        }
    }
}

4. Critical Setup & Notes #

• Network Permission: Add the internet permission to your AndroidManifest.xml—you can't make network calls without this:

  <uses-permission android:name="android.permission.INTERNET" />
  

• Backend URL: Never use localhost when testing on an Android device/emulator. Instead, use your computer's local IP address (find it via ipconfig on Windows or ifconfig on macOS/Linux).
• Main Thread Updates: Android requires all UI updates to happen on the main thread. The example uses a Handler to ensure this—don't skip this step, or you'll get runtime errors.
• Reconnection: For production apps, add logic to retry connecting if the connection drops (listen to the CLOSED lifecycle event and call connectToBackend() after a short delay).
• SockJS Fallback: If your app needs to work in environments where WebSockets are blocked, switch to the SockJS URL format in the StompChatManager.

5. Use the Manager in Your App #

You can use this manager in an Activity like this:

public class ChatActivity extends AppCompatActivity {
    private StompChatManager mChatManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);
        
        mChatManager = new StompChatManager();
        mChatManager.connectToBackend();

        // Example: Send a message when a button is clicked
        Button sendBtn = findViewById(R.id.send_btn);
        sendBtn.setOnClickListener(v -> {
            mChatManager.sendMessageToTopic("chatroom1", "MyUsername", "Hello from Android!");
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mChatManager.disconnectFromBackend();
    }
}

That's all! Your Android app should now be able to connect to your Spring Boot STOMP backend, send messages, and receive broadcasts from the specified topic.

内容的提问来源于stack exchange，提问作者Daksh Verma