Wie sende ich eine POST-Anfrage mit PHP?

Eigentlich möchte ich den Inhalt lesen, der nach der Suchabfrage kommt, wenn es fertig ist. Das Problem ist, dass die URL nur POSTMethoden akzeptiert und mit GETmethod keine Aktion ausführt ...

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

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 Headern finden Sie im PHP-Handbuch, zum Beispiel:

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

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, 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 benutze die folgende Funktion, um Daten mit Curl zu posten. $ data ist ein Array von Feldern, die veröffentlicht werden sollen (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 weggelassen wird, da curl das an den Parameter CURLOPT_POSTFIELDS übergebene Array korrekt codiert. In diesem Fall werden die Daten jedoch mithilfe von Multipart- / Formulardaten codiert.

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

Ich empfehle Ihnen, die Open-Source- Paketfresser zu verwenden , die vollständig auf Einheitentests getestet wurde und die neuesten Codierungsmethoden verwendet.

Guzzle installieren

Gehen Sie zur Befehlszeile in Ihrem Projektordner und geben Sie den folgenden Befehl ein (vorausgesetzt, Sie haben den Paketmanager- Composer bereits 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-Anfrage

Die Verwendung von Guzzle ist sehr einfach, da eine leichte objektorientierte API 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);

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

Dies ist ziemlich einfach, wenn Sie sich erst einmal mit der Funktionsweise der PHP-Curl-Erweiterung vertraut gemacht haben und 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 in der Testmethode des Beispiels 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 () festgelegt. 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, die Ausgabe als Rückgabewert von curl_exec anzugeben, anstatt sie auszugeben. Dann rufen wir an und schließen die Verbindung - das Ergebnis ist eine Antwort von $.

Wenn Sie zufällig Wordpress verwenden, um Ihre App zu entwickeln (es ist tatsächlich eine bequeme Möglichkeit, Autorisierungen, Infoseiten usw. zu erhalten, selbst für sehr einfache Dinge), 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, werden verschiedene Methoden zum Erstellen der eigentlichen HTTP-Anforderung verwendet. Weitere Informationen finden Sie in der Dokumentation zur HTTP-API .

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 einfach Folgendes tun:

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

// ... your code

Es wird kein Thema angezeigt oder HTML ausgegeben. Hacken Sie einfach mit den Wordpress-APIs!

Ich möchte einige Gedanken zur lockenbasierten Antwort von Fred Tanrikut hinzufügen. Ich weiß, dass die meisten von ihnen bereits in den obigen Antworten 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 stellen, 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 von http_build_query, um die Abfragezeichenfolge aus einem Anforderungsarray abzurufen (Sie können 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 curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, true) entfernen. . Danach ist der Rückgabewert ein Boolescher Wert (true = Anfrage war erfolgreich, andernfalls ist ein Fehler aufgetreten) und die Antwort wird wiederholt. Siehe: http://php.net/en/manual/function.curl-exec.php
• Bereinigen Sie das Schließen und Löschen der Sitzung des Curl- Handlers mithilfe von curl_close . Siehe: http://php.net/manual/en/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 ebenfalls als wahr angesehen wird, aber die Verwendung von wahr erzeugt einen besser lesbaren Code, aber das ist nur meine Meinung).
• Möglichkeit zum Ausführen von HTTP-PUT / DELETE-Aufrufen (nützlich für RESTful-Servicetests)

Anwendungsbeispiel

ERHALTEN

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

Eine andere Alternative der oben beschriebenen Methode ohne Locken besteht darin, die nativen Stream- Funktionen zu verwenden:

• stream_context_create()::

  Erstellt einen Stream-Kontext mit allen in der Optionsvoreinstellung angegebenen Optionen und gibt diesen zurück .

• stream_get_contents()::

  Identisch mit file_get_contents(), außer dass dies stream_get_contents() auf einer bereits geöffneten Stream- Ressource ausgeführt wird und den verbleibenden Inhalt in einer Zeichenfolge bis zu einer maximalen Länge von Bytes und beginnend mit dem angegebenen Offset zurückgibt .

Eine POST-Funktion mit diesen kann einfach so 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) {
    return json_encode(['error' => 'Failed to get contents...']);
  }
  $result = stream_get_contents($fp); // no maxlength/offset
  fclose($fp);
  return $result;
}

Der bessere Weg zum Senden GEToder POSTAnfragen mit PHPist 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://docs.php.net/manual/da/httprequest.send.php

Es gibt noch eine, die 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

Ich suchte nach einem ähnlichen Problem und fand einen besseren Ansatz dafür. Also los geht's.

Sie können einfach die folgende Zeile auf die Umleitungsseite setzen (z. B. 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 umzuleiten REST- API-Aufrufe . Diese Lösung kann sowohl mit Post-Daten als auch mit benutzerdefinierten Header-Werten umleiten.

Hier ist der Referenzlink .

Hier wird nur ein Befehl ohne cURL verwendet. Super einfach.

echo file_get_contents('https://www.server.com', false, stream_context_create([
    'http' => [
        'method' => 'POST',
        'header'  => "Content-type: application/x-www-form-urlencoded",
        'content' => http_build_query([
            'key1' => 'Hello world!', 'key2' => 'second value'
        ])
    ]
]));

Probieren Sie das Paket HTTP_Request2 von PEAR aus , um POST-Anforderungen einfach zu senden. Alternativ können Sie die Curl-Funktionen von PHP oder einen PHP- Stream-Kontext verwenden .

HTTP_Request2 ermöglicht es auch , den Server zu verspotten , sodass Sie Ihren Code problemlos einem Unit-Test unterziehen können