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?
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:
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;
?>
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 ().
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);
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.
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!
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;
}
}
$response = HTTPRequester::HTTPGet("http://localhost/service/foobar.php", array("getParam" => "foobar"));
$response = HTTPRequester::HTTPPost("http://localhost/service/foobar.php", array("postParam" => "foobar"));
$response = HTTPRequester::HTTPPut("http://localhost/service/foobar.php", array("putParam" => "foobar"));
$response = HTTPRequester::HTTPDelete("http://localhost/service/foobar.php", array("deleteParam" => "foobar"));
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}]');
}
}
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, dassstream_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;
}
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);
?>
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 .
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
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