Wie sende ich eine POST-Anfrage mit PHP?

Eigentlich möchte ich die Inhalte lesen, die nach der Suchanfrage kommen, wenn diese fertig ist. Das Problem ist, dass die URL nur akzeptiert POST Methoden, und es werden keine Aktionen ausgeführt GET Methode…

Ich muss alle Inhalte mit Hilfe von lesen domdocument oder file_get_contents(). Gibt es eine Methode, mit der ich Parameter senden kann? POST Methode und lesen Sie dann den Inhalt über PHP?

CURL-lose Methode mit PHP5:

$url="http://server.com/path";
$data = array('key1' => 'value1', 'key2' => 'value2');

// use key 'http' even if you send the request to https://...
$options = array(
    'http' => array(
        'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
        'method'  => 'POST',
        'content' => http_build_query($data)
    )
);
$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
if ($result === FALSE) { /* Handle error */ }

var_dump($result);

Weitere Informationen zur Methode und zum Hinzufügen von Headern finden Sie im PHP-Handbuch, zum Beispiel:

• stream_context_create: http://php.net/manual/en/function.stream-context-create.php

Du könntest benutzen cURL:

<?php
//The url you wish to send the POST request to
$url = $file_name;

//The data you want to send via POST
$fields = [
    '__VIEWSTATE '      => $state,
    '__EVENTVALIDATION' => $valid,
    'btnSubmit'         => 'Submit'
];

//url-ify the data for the POST
$fields_string = http_build_query($fields);

//open connection
$ch = curl_init();

//set the url, number of POST vars, POST data
curl_setopt($ch,CURLOPT_URL, $url);
curl_setopt($ch,CURLOPT_POST, true);
curl_setopt($ch,CURLOPT_POSTFIELDS, $fields_string);

//So that curl_exec returns the contents of the cURL; rather than echoing it
curl_setopt($ch,CURLOPT_RETURNTRANSFER, true); 

//execute post
$result = curl_exec($ch);
echo $result;
?>

Ich verwende die folgende Funktion, um Daten mit curl zu posten. $data ist ein Array von zu postenden Feldern (wird mit http_build_query korrekt codiert). Die Daten werden mit application/x-www-form-urlencoded verschlüsselt.

function httpPost($url, $data)
{
    $curl = curl_init($url);
    curl_setopt($curl, CURLOPT_POST, true);
    curl_setopt($curl, CURLOPT_POSTFIELDS, http_build_query($data));
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($curl);
    curl_close($curl);
    return $response;
}

@Edward erwähnt, dass http_build_query weggelassen werden kann, da curl das an den Parameter CURLOPT_POSTFIELDS übergebene Array korrekt codiert, aber beachten Sie, dass in diesem Fall die Daten mit multipart/form-data codiert werden.

Ich verwende diese Funktion mit APIs, die erwarten, dass Daten mit application/x-www-form-urlencoded codiert werden. Deshalb verwende ich http_build_query().

Ich empfehle Ihnen, das Open-Source-Paket zu verwenden fressen das vollständig einheitengetestet ist und die neuesten Codierungspraktiken verwendet.

Guzzle installieren

Gehen Sie zur Befehlszeile in Ihrem Projektordner und geben Sie den folgenden Befehl ein (vorausgesetzt, Sie haben bereits den Paketmanager Komponist Eingerichtet). Wenn Sie Hilfe bei der Installation von Composer benötigen, sollten Sie hier nachsehen.

php composer.phar require guzzlehttp/guzzle

Verwenden von Guzzle zum Senden einer POST-Anfrage

Die Verwendung von Guzzle ist sehr einfach, da es eine leichte objektorientierte API verwendet:

// Initialize Guzzle client
$client = new GuzzleHttp\Client();

// Create a POST request
$response = $client->request(
    'POST',
    'http://example.org/',
    [
        'form_params' => [
            'key1' => 'value1',
            'key2' => 'value2'
        ]
    ]
);

// Parse the response object, e.g. read the headers, body, etc.
$headers = $response->getHeaders();
$body = $response->getBody();

// Output headers and body for debugging purposes
var_dump($headers, $body);

Ich möchte einige Gedanken zur Locken-basierten Antwort von Fred Tanrikut hinzufügen. Ich weiß, dass die meisten von ihnen bereits in den Antworten oben geschrieben sind, aber ich denke, es ist eine gute Idee, eine Antwort zu zeigen, die alle zusammen enthält.

Hier ist die Klasse, die ich geschrieben habe, um HTTP-GET/POST/PUT/DELETE-Anforderungen basierend auf curl zu erstellen, die nur den Antworttext betrifft:

class HTTPRequester {
    /**
     * @description Make HTTP-GET call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPGet($url, array $params) {
        $query = http_build_query($params); 
        $ch    = curl_init($url.'?'.$query);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HEADER, false);
        $response = curl_exec($ch);
        curl_close($ch);
        return $response;
    }
    /**
     * @description Make HTTP-POST call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPPost($url, array $params) {
        $query = http_build_query($params);
        $ch    = curl_init();
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HEADER, false);
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $query);
        $response = curl_exec($ch);
        curl_close($ch);
        return $response;
    }
    /**
     * @description Make HTTP-PUT call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPPut($url, array $params) {
        $query = \http_build_query($params);
        $ch    = \curl_init();
        \curl_setopt($ch, \CURLOPT_RETURNTRANSFER, true);
        \curl_setopt($ch, \CURLOPT_HEADER, false);
        \curl_setopt($ch, \CURLOPT_URL, $url);
        \curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, 'PUT');
        \curl_setopt($ch, \CURLOPT_POSTFIELDS, $query);
        $response = \curl_exec($ch);
        \curl_close($ch);
        return $response;
    }
    /**
     * @category Make HTTP-DELETE call
     * @param    $url
     * @param    array $params
     * @return   HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPDelete($url, array $params) {
        $query = \http_build_query($params);
        $ch    = \curl_init();
        \curl_setopt($ch, \CURLOPT_RETURNTRANSFER, true);
        \curl_setopt($ch, \CURLOPT_HEADER, false);
        \curl_setopt($ch, \CURLOPT_URL, $url);
        \curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, 'DELETE');
        \curl_setopt($ch, \CURLOPT_POSTFIELDS, $query);
        $response = \curl_exec($ch);
        \curl_close($ch);
        return $response;
    }
}

Verbesserungen

• Verwenden von http_build_query, um den Abfragestring aus einem Anfrage-Array zu erhalten. (Sie könnten auch das Array selbst verwenden, siehe daher: http://php.net/manual/en/function.curl-setopt.php)
• Die Antwort zurückgeben, anstatt sie zu wiederholen. Übrigens können Sie die Rückkehr vermeiden, indem Sie die Zeile entfernen curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);. Danach ist der Rückgabewert ein boolescher Wert (true = Anfrage war erfolgreich, sonst ist ein Fehler aufgetreten) und die Antwort wird zurückgemeldet. Sehen: http://php.net/en/manual/function.curl-exec.php
• Sauberes Schließen der Sitzung und Löschen des Curl-Handlers durch using curl_close. Sehen: http://php.net/manual/en/function.curl-close.php
• Verwenden von booleschen Werten für die curl_setopt Funktion, anstatt eine Zahl zu verwenden. (Ich weiß, dass jede Zahl ungleich Null auch als wahr angesehen wird, aber die Verwendung von wahr erzeugt einen besser lesbaren Code, aber das ist nur meine Meinung.)
• Möglichkeit, HTTP-PUT/DELETE-Aufrufe durchzuführen (nützlich für RESTful-Service-Tests)

Anwendungsbeispiel

BEKOMMEN

$response = HTTPRequester::HTTPGet("http://localhost/service/foobar.php", array("getParam" => "foobar"));

POST

$response = HTTPRequester::HTTPPost("http://localhost/service/foobar.php", array("postParam" => "foobar"));

SETZEN

$response = HTTPRequester::HTTPPut("http://localhost/service/foobar.php", array("putParam" => "foobar"));

LÖSCHEN

$response = HTTPRequester::HTTPDelete("http://localhost/service/foobar.php", array("deleteParam" => "foobar"));

Testen

Mit dieser einfachen Klasse können Sie auch einige coole Servicetests durchführen.

class HTTPRequesterCase extends TestCase {
    /**
     * @description test static method HTTPGet
     */
    public function testHTTPGet() {
        $requestArr = array("getLicenses" => 1);
        $url        = "http://localhost/project/req/licenseService.php";
        $this->assertEquals(HTTPRequester::HTTPGet($url, $requestArr), '[{"error":false,"val":["NONE","AGPL","GPLv3"]}]');
    }
    /**
     * @description test static method HTTPPost
     */
    public function testHTTPPost() {
        $requestArr = array("addPerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPPost($url, $requestArr), '[{"error":false}]');
    }
    /**
     * @description test static method HTTPPut
     */
    public function testHTTPPut() {
        $requestArr = array("updatePerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPPut($url, $requestArr), '[{"error":false}]');
    }
    /**
     * @description test static method HTTPDelete
     */
    public function testHTTPDelete() {
        $requestArr = array("deletePerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPDelete($url, $requestArr), '[{"error":false}]');
    }
}

Es gibt eine andere CURL-Methode, wenn Sie diesen Weg gehen.

Dies ist ziemlich einfach, sobald Sie sich mit der Funktionsweise der PHP-Curl-Erweiterung vertraut gemacht haben, indem Sie verschiedene Flags mit setopt() -Aufrufen kombinieren. In diesem Beispiel habe ich eine Variable $xml, die das XML enthält, das ich zum Senden vorbereitet habe – ich werde den Inhalt davon an die Testmethode des Beispiels senden.

$url="http://api.example.com/services/xmlrpc/";
$ch = curl_init($url);

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $xml);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
//process $response

Zuerst haben wir die Verbindung initialisiert, dann haben wir einige Optionen mit setopt() gesetzt. Diese teilen PHP mit, dass wir eine Post-Anfrage stellen und dass wir einige Daten damit senden und die Daten liefern. Das CURLOPT_RETURNTRANSFER-Flag weist curl an, uns die Ausgabe als Rückgabewert von curl_exec zu geben, anstatt sie auszugeben. Dann führen wir den Aufruf durch und schließen die Verbindung – das Ergebnis steht in $response.

Wenn Sie zufällig WordPress verwenden, um Ihre App zu entwickeln (es ist eigentlich eine bequeme Möglichkeit, Autorisierungen, Infoseiten usw. selbst für sehr einfache Dinge zu erhalten), können Sie das folgende Snippet verwenden:

$response = wp_remote_post( $url, array('body' => $parameters));

if ( is_wp_error( $response ) ) {
    // $response->get_error_message()
} else {
    // $response['body']
}

Je nachdem, was auf dem Webserver verfügbar ist, verwendet es verschiedene Wege, um die eigentliche HTTP-Anfrage zu stellen. Weitere Einzelheiten finden Sie unter HTTP-API-Dokumentation.

Wenn Sie kein benutzerdefiniertes Design oder Plugin zum Starten der WordPress-Engine entwickeln möchten, können Sie einfach Folgendes in einer isolierten PHP-Datei im WordPress-Root tun:

require_once( dirname(__FILE__) . '/wp-load.php' );

// ... your code

Es wird kein Design anzeigen oder HTML ausgeben, hacken Sie einfach mit den WordPress-APIs los!