Hey there! Let's break this down step by step since you're new to Android Java clients but have Qt Socket experience—some network concepts will overlap, but we'll focus on Android-specific implementations and common pitfalls you might be hitting.

First: Fix the "Can't Connect" Issues #

Before diving into code, let's rule out the most common connection blockers:

• Local Server Access: If your Node.js API runs on your computer, Android emulators can't use localhost. Use 10.0.2.2 (for Android Studio's default emulator) or your computer's local LAN IP (like 192.168.1.100) instead.
• Network Permissions: Add this to your AndroidManifest.xml (outside the <application> tag):

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

• Cleartext HTTP (Android 9+): If your API uses HTTP (not HTTPS), add this attribute to the <application> tag in AndroidManifest.xml to allow unencrypted traffic:

  android:usesCleartextTraffic="true"
  

• CORS on Node.js: Your Android client counts as a cross-origin request. Install the cors middleware in your Node.js project and enable it:

  const cors = require('cors');
  app.use(cors());
  

Code Example 1: Volley (Google's Recommended Library) #

Volley simplifies network requests and handles threading automatically—great for beginners.

Step 1: Add Volley Dependency #

In your app/build.gradle (Module level), add this to the dependencies block:

implementation 'com.android.volley:volley:1.2.1'

Step 2: API Client Class with Update Method #

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.Volley;
import org.json.JSONObject;
import android.content.Context;
import android.widget.Toast;

public class UserApiClient {
    private static RequestQueue requestQueue;

    // Initialize Volley's request queue (singleton pattern)
    private static void initRequestQueue(Context context) {
        if (requestQueue == null) {
            requestQueue = Volley.newRequestQueue(context.getApplicationContext());
        }
    }

    // Method to update a user
    public static void updateUser(Context context, int userId, String newName, String newPassword, final UpdateCallback callback) {
        initRequestQueue(context);

        // Replace with your API URL (use 10.0.2.2 for local emulator access)
        String apiUrl = "http://10.0.2.2:3000/users/" + userId;

        // Build the JSON body to send
        JSONObject requestBody = new JSONObject();
        try {
            requestBody.put("name", newName);
            requestBody.put("password", newPassword);
        } catch (Exception e) {
            e.printStackTrace();
            callback.onFailure("Failed to create request data");
            return;
        }

        // Create PUT request (adjust method to POST/PATCH if your API uses it)
        JsonObjectRequest updateRequest = new JsonObjectRequest(
                Request.Method.PUT,
                apiUrl,
                requestBody,
                response -> callback.onSuccess("Update successful: " + response.toString()),
                error -> {
                    String errorMsg = error.getMessage() != null ? error.getMessage() : "Unknown error";
                    callback.onFailure("Request failed: " + errorMsg);
                }
        );

        requestQueue.add(updateRequest);
    }

    // Callback interface to handle results
    public interface UpdateCallback {
        void onSuccess(String result);
        void onFailure(String error);
    }
}

Step 3: Call the Method in Your Activity #

// Example: Update user with ID 1
UserApiClient.updateUser(
        MainActivity.this,
        1,
        "Tom Updated",
        "newSecurePass123",
        new UserApiClient.UpdateCallback() {
            @Override
            public void onSuccess(String result) {
                // Run UI updates on the main thread
                runOnUiThread(() -> Toast.makeText(MainActivity.this, result, Toast.LENGTH_SHORT).show());
            }

            @Override
            public void onFailure(String error) {
                runOnUiThread(() -> Toast.makeText(MainActivity.this, error, Toast.LENGTH_SHORT).show());
            }
        }
);

Code Example 2: HttpURLConnection (Low-Level Alternative) #

If you want to understand the underlying network flow, here's how to do it with HttpURLConnection (note: you must run this off the main thread):

import android.os.AsyncTask;
import android.widget.Toast;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class UpdateUserTask extends AsyncTask<Void, Void, String> {
    private final int userId;
    private final String newName;
    private final String newPassword;
    private final MainActivity activity;

    public UpdateUserTask(int userId, String newName, String newPassword, MainActivity activity) {
        this.userId = userId;
        this.newName = newName;
        this.newPassword = newPassword;
        this.activity = activity;
    }

    @Override
    protected String doInBackground(Void... voids) {
        HttpURLConnection connection = null;
        BufferedReader reader = null;
        try {
            URL url = new URL("http://10.0.2.2:3000/users/" + userId);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("PUT");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);

            // Build JSON body
            JSONObject jsonBody = new JSONObject();
            jsonBody.put("name", newName);
            jsonBody.put("password", newPassword);
            String jsonString = jsonBody.toString();

            // Send data
            try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
                outputStream.writeBytes(jsonString);
                outputStream.flush();
            }

            // Read response
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                return "Update successful: " + response.toString();
            } else {
                return "Request failed with code: " + responseCode;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return "Error: " + e.getMessage();
        } finally {
            if (connection != null) connection.disconnect();
            if (reader != null) {
                try { reader.close(); } catch (Exception e) { e.printStackTrace(); }
            }
        }
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Toast.makeText(activity, result, Toast.LENGTH_SHORT).show();
    }
}

Call the Task in Your Activity #

new UpdateUserTask(1, "Tom Updated", "newPass123", MainActivity.this).execute();

Using Gson for JSON Parsing/Serialization #

Gson makes working with JSON objects and Java classes easier. Add the dependency first:

implementation 'com.google.code.gson:gson:2.10.1'

Step 1: Create a User Model Class #

public class User {
    private int id;
    private String name;
    private String password;

    // Constructor, getters, and setters
    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    // Getters and setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
}

Step 2: Serialize/Deserialize with Gson #

import com.google.gson.Gson;

// Convert User object to JSON string
User updatedUser = new User(1, "Tom Updated", "newPass123");
Gson gson = new Gson();
String jsonString = gson.toJson(updatedUser);

// Convert JSON response back to User object
User responseUser = gson.fromJson(jsonResponseString, User.class);

Final Tips #

• Never run network code on the main thread: Volley handles this automatically, but with HttpURLConnection you must use AsyncTask, ExecutorService, or coroutines (if you switch to Kotlin later).
• Test your API first: Use tools like Postman or curl to confirm your Node.js API works before connecting the Android client.
• Check logcat: Android Studio's Logcat tab will show detailed error messages (like connection timeouts, CORS issues) that can help debug.

内容的提问来源于stack exchange，提问作者Владислав Соболь