wake-up-neo.com

Wie sende ich eine POST Anfrage mit PHP?

Eigentlich möchte ich die Inhalte lesen, die nach der Suchanfrage kommen, wenn sie fertig ist. Das Problem ist, dass die URL nur POST-Methoden akzeptiert und mit der GET-Methode keine Aktion ausführt ...

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

phphttppostrequest
573
Fred Tanrikut

CURL-freie 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 Kopfzeilen finden Sie im Handbuch PHP. Beispiel:

1128
dbau

Sie könnten cURL verwenden:

<?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, count($fields));
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;
?>
86
Fred Tanrikut

Ich verwende die folgende Funktion, um Daten mit curl zu veröffentlichen. $ data ist ein Array von Feldern, die gepostet werden müssen (wird mit http_build_query korrekt codiert). Die Daten werden mit application/x-www-form-urlencoded codiert.

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 möglicherweise ausgelassen wird, da curl das an den Parameter CURLOPT_POSTFIELDS übergebene Array korrekt codiert. Beachten Sie jedoch, dass in diesem Fall die Daten mit Multipart/Form-Daten codiert werden.

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

53
Dima L.

Ich empfehle Ihnen, das Open-Source-Paket guzzle zu verwenden, das vollständig getestet wurde und die neuesten Kodierungsmethoden verwendet.

Installieren von Guzzle

Gehen Sie zur Befehlszeile in Ihrem Projektordner und geben Sie den folgenden Befehl ein (vorausgesetzt, Sie haben bereits den Paketmanager composer installiert). 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 -Anforderung

Die Verwendung von Guzzle ist sehr einfach, da eine objektorientierte API mit geringem Gewicht verwendet wird:

// 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);
36
Andreas

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

Dies ist ziemlich unkompliziert, wenn Sie sich mit der Funktionsweise der PHP -Lockenerweiterung auseinandersetzen und verschiedene Flags mit setopt () - Aufrufen kombinieren. In diesem Beispiel habe ich eine Variable $ xml, die das zu sendende XML enthält. Ich werde den Inhalt dieser Methode in der Testmethode von example veröffentlichen.

$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 sagen PHP, dass wir eine Post-Anfrage stellen und dass wir einige Daten mitsenden, die die Daten liefern. Das CURLOPT_RETURNTRANSFER-Flag weist curl an, uns die Ausgabe als Rückgabewert von curl_exec zu geben, anstatt es auszugeben. Dann machen wir den Anruf und schließen die Verbindung - das Ergebnis ist in $ response.

23
Josip Ivic

Wenn Sie Wordpress verwenden, um Ihre App zu entwickeln (es ist tatsächlich eine bequeme Methode, um Autorisierung, Infoseiten usw. auch für sehr einfache Dinge zu erhalten), können Sie den folgenden Ausschnitt 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, werden verschiedene Methoden zum Durchführen der tatsächlichen HTTP-Anforderung verwendet. Weitere Informationen finden Sie in der HTTP-API-Dokumentation .

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

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

// ... your code

Es wird kein Thema angezeigt oder HTML ausgegeben, hacken Sie einfach die Wordpress-APIs ein!

18
user3638471

Ich möchte einige Gedanken zu der auf Curl basierenden Antwort von Fred Tanrikut hinzufügen. Ich weiß, dass die meisten von ihnen bereits in den obigen Antworten enthalten 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 auf Curl-Basis zu erstellen, die sich nur auf den Antworttext beziehen:

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 Sie http_build_query, um die Abfragezeichenfolge aus einem Request-Array zu erhalten (Sie können auch das Array selbst verwenden. Siehe hierzu: http://php.net/manual/de/function.curl-setopt.php )
  • Antwort zurückschicken, anstatt sie zu wiederholen. Übrigens können Sie die Rückkehr vermeiden, indem Sie die Zeile curl_setopt entfernen ($ ch, CURLOPT_RETURNTRANSFER, true);. Danach ist der Rückgabewert ein boolescher Wert (true = Anforderung war erfolgreich, andernfalls ist ein Fehler aufgetreten) und die Antwort wird bestätigt. Siehe: http://php.net/de/manual/function.curl-exec.php
  • Säubern Sie das Schließen und Löschen des Curl-Handlers mit curl_close. Siehe: http://php.net/manual/de/function.curl-close.php
  • Die Verwendung von booleschen Werten für die Funktion curl_setopt anstelle einer beliebigen Zahl. (Ich weiß, dass jede Zahl ungleich Null auch als wahr betrachtet wird. Die Verwendung von true erzeugt jedoch einen lesbareren Code. Dies ist jedoch nur meine Meinung)
  • Möglichkeit, HTTP-PUT/DELETE-Aufrufe durchzuführen (nützlich für RESTful-Service-Tests)

Verwendungsbeispiel

GET

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

POST

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

STELLEN

$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 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}]');
    }
}
16
mwatzer

Eine weitere Alternative der Methode curl-less oben ist die Verwendung der systemeigenen Funktionen stream:

  • stream_context_create() :

    Erstellt einen Stream-Kontext mit allen Optionen, die in der Voreinstellung options angegeben sind, und gibt diesen zurück.

  • stream_get_contents() :

    Identisch mit file_get_contents() , mit der Ausnahme, dass stream_get_contents()auf einer bereits offenen Stream - Ressource arbeitet und den restlichen Inhalt in einer Zeichenfolge zurückgibt, bis zu maxlength Byte und beginnend am angegebenen offset.

Eine POST - Funktion mit diesen kann einfach wie folgt aussehen:

<?php

function post_request($url, array $params) {
  $query_content = http_build_query($params);
  $fp = fopen($url, 'r', FALSE, // do not use_include_path
    stream_context_create([
    'http' => [
      'header'  => [ // header array does not need '\r\n'
        'Content-type: application/x-www-form-urlencoded',
        'Content-Length: ' . strlen($query_content)
      ],
      'method'  => 'POST',
      'content' => $query_content
    ]
  ]));
  if ($fp === FALSE) {
    fclose($fp);
    return json_encode(['error' => 'Failed to get contents...']);
  }
  $result = stream_get_contents($fp); // no maxlength/offset
  fclose($fp);
  return $result;
}
10
CPHPython

Es gibt noch einen, den Sie verwenden können

<?php
$fields = array(
    'name' => 'mike',
    'pass' => 'se_ret'
);
$files = array(
    array(
        'name' => 'uimg',
        'type' => 'image/jpeg',
        'file' => './profile.jpg',
    )
);

$response = http_post_fields("http://www.example.com/", $fields, $files);
?>

Hier klicken für Details

5
Code

Ich suchte nach einem ähnlichen Problem und fand einen besseren Ansatz, um dies zu tun. Also hier geht es.

Sie können einfach die folgende Zeile auf die Umleitungsseite setzen (zB page1.php).

header("Location: URL", TRUE, 307); // Replace URL with to be redirected URL, e.g. final.php

Ich brauche dies, um POST -Anfragen für REST API-Aufrufe umzuleiten. Diese Lösung kann Post-Daten sowie benutzerdefinierte Header-Werte umleiten.

Hier ist der Referenzlink .

5
Arindam Nayak

Probieren Sie das Paket HTTP_Request2 von PEAR aus, um auf einfache Weise POST -Anfragen zu senden. Alternativ können Sie die Curl-Funktionen von PHP oder einen PHP stream context verwenden.

HTTP_Request2 ermöglicht es auch, den Server zu verspotten, so dass Sie Ihren Code einfach testen können

1
cweiske

Der bessere Weg, GET- oder POST-Anforderungen mit PHP zu senden, ist wie folgt:

<?php
    $r = new HttpRequest('http://example.com/form.php', HttpRequest::METH_POST);
    $r->setOptions(array('cookies' => array('lang' => 'de')));
    $r->addPostFields(array('user' => 'mike', 'pass' => 's3c|r3t'));

    try {
        echo $r->send()->getBody();
    } catch (HttpException $ex) {
        echo $ex;
    }
?>

Der Code stammt aus der offiziellen Dokumentation hier http://php.net/manual/it/httprequest.send.php

0
Imran Zahoor