Kann mir jemand, Schritt für Schritt, die Interaktion zwischen meinem Android-Client und dem PHP-Server in meinem Beispiel erklären?

Question

username;

echo "Result: \n";
echo "---------------\n";
echo "username : ", $username, "\n";

?>

public String postJSON() throws JSONException{
    HttpClient httpclient = new DefaultHttpClient();
    HttpPost httppost = new HttpPost(ec2Url + "testjson.php");
    JSONObject json = new JSONObject();

    try {
        json.put("username", "Michael");
        JSONArray postjson = new JSONArray();
        postjson.put(json);

        httppost.setHeader("json", json.toString());
        Log.d(DEBUG_TAG, "toString() " + json.toString());
        httppost.getParams().setParameter("jsonpost", postjson);

        HttpResponse response = httpclient.execute(httppost);

        if(response != null) {
            InputStream is = response.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder sb = new StringBuilder();

            String line = null;

            try {
                while((line = reader.readLine()) != null) {
                    sb.append(line + "\n");
                }
            } catch(IOException e){

            }
            text = sb.toString();
        }
    return text;} 

    catch (ClientProtocolException e) {

    } catch(IOException e){

    }
    return "BROKE";
}

The code works, but I do not entirely understand it. Kann mir jemand erklären, was httppost.setHeader("json", json.toString()) tut und wie $_SERVER['HTTP_JSON'] gleich json.toString() gesetzt wird? Außerdem, was macht httppost.getParams().setParameter("jsonpost", postjson)? Es scheint "jsonpost" und das JSON-Array selbst zusammenzuarbeiten, aber wo wird das in PHP empfangen und interpretiert?

Ich habe in der Vergangenheit ein paar schlechte Fragen gestellt, daher wenn dies nicht als "on topic" gilt oder unklar ist, zögern Sie nicht, mir Bescheid zu sagen, damit ich es bearbeiten kann.

Answer 1

Praktisch gesehen ist dieser Code ein wenig seltsam und kein Beispiel für gute Praktiken, aber glücklicherweise ist es gut über die involvierten Konzepte nachzudenken.

Um es zu verstehen, erfordert es eine Einführung in HTTP. Aber um die Dinge weniger schmerzhaft zu gestalten, werde ich versuchen zu vereinfachen. Der Client (Android App) und der Server (PHP auf einem HTTP-Server ausgeführt) senden sich Strings (Ströme von textuellen Daten, um genauer zu sein) gegenseitig, jeweils einzeln. Diese Strings werden als HTTP-Nachrichten bezeichnet.

HTTP-Nachrichten haben immer einen Anfangsteil, genannt HTTP-Header. Nach dem Header ist es möglich, aber nicht notwendig, einen HTTP-Body zu enthalten. Diese Teile sind jeweils durch zwei aufeinanderfolgende Leerzeilen voneinander getrennt.

Der Android-Code sendet einen spezifischen Typ von HTTP-Nachricht: ein POST (HTTP-Nachrichten existieren in der Tat nicht, es ist ein 'abstraktes Konzept'). Ein POST kann einen Body enthalten, und im Allgemeinen tut dies auch.

Der erste Teil Ihrer Fragen dreht sich um die Vorbereitung des POST, also lassen Sie uns mit den Endergebnissen beginnen (hier ist eine Annäherung des POST, den Ihr Android-Code an den Server sendet):

POST /testjson.php HTTP/1.1
Host: content.of.your.ec2Url.string
User-Agent: Android Http Client User-Agent
Content-Length: 0
json: {"username": "Michael"}
                                     <- neue Zeile hier, Ende der Header, kein Body

Die erste Zeile definiert den Typ der Nachricht (POST), die Ressource, die auf dem Server erreicht werden soll (/testjson.php) und die HTTP-Version des Clients (HTTP/1.1). Es folgen die HTTP-Header. Header sind eine einfache Gruppe von durch Doppelpunkt getrennten Schlüssel/Wert-Paaren. Sie sind für HTTP wesentlich, um mit vielen Problemen umzugehen, die die Verhandlungsfähigkeiten zwischen Client und Servern, Cache-Control, Berechtigungen, die Definition der Größe, des Typs und der Möglichkeiten zum Lesen von Bodies betreffen.

Was wirklich unkonventionell am Android-Code (und folglich am generierten POST) ist, dass Anwendungsdaten innerhalb eines HTTP-Headers gesendet werden, nicht im Body oder in der ersten Zeile des HTTP. Es ist nicht der richtige Weg, es zu tun, aber es ist möglich. httppost.setHeader("json", json.toString()) handelt genau davon: Setzen eines Headers mit dem Namen json und dem Wert von json.toString().

Also gibt es dieses httppost.getParams().setParameter("jsonpost", postjson), und ich gestehe, dass ich mir über dessen Auswirkungen nicht sicher bin. Es scheint fehlplatziert zu sein. httppost.getParams() gibt ein Objekt von HttpParams zurück, das verwendet wird, um HTTP-Protokoll-spezifische Dinge zu ändern, die hier definiert sind, und hier, nicht um beliebige Anwendungsdaten zu setzen. Trotzdem scheint es ein üblicher Fehler zu sein.

Zuletzt die PHP-Sachen, aber das ist viel einfacher: In PHP werden alle HTTP-Header in einer $_SERVER[HTTP_NAME_OF_HEADER] Variable umgewandelt (der Header-Schlüssel wird großgeschrieben und '-' durch '_' ersetzt). Es ist kein dokumentiertes Merkmal (tatsächlich ist es teilweise dokumentiert), aber ich habe es in den letzten zehn Jahren benutzt, ohne es zu bemerken. Also:

$_SERVER['HTTP_HOST'];            // entspricht content.of.your.ec2Url.string
$_SERVER['HTTP_USER_AGENT'];      // entspricht Android Http Client User-Agent
$_SERVER['HTTP_CONTENT_LENGTH'];  // entspricht 0
//und schließlich
$_SERVER['HTTP_JSON'];            // entspricht {"username": "Michael"}