php - Hoe verzend ik een POST-verzoek met PHP?

Eigenlijk wil ik de inhoud lezen die na de zoekopdracht komt, wanneer deze klaar is. Het probleem is dat de URL alleen POST-methoden accepteert en geen actie onderneemt met de GET-methode…

Ik moet alle inhoud lezen met behulp van domdocumentof file_get_contents(). Is er een methode waarmee ik parameters kan verzenden met de POST-methode en vervolgens de inhoud kan lezen via PHP?

Antwoord 1, autoriteit 100%

CURL-loze methode met 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);

Zie de PHP-handleiding voor meer informatie over de methode en het toevoegen van headers, bijvoorbeeld:

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

Antwoord 2, autoriteit 12%

Je zou cURL:

kunnen gebruiken

<?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;
?>

Antwoord 3, autoriteit 6%

Ik gebruik de volgende functie om gegevens te posten met curl. $data is een array van velden om te posten (wordt correct gecodeerd met behulp van http_build_query). De gegevens zijn gecodeerd met application/x-www-form-urlencoded.

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 vermeldt dat http_build_query kan worden weggelaten omdat curl de array correct codeert die wordt doorgegeven aan de parameter CURLOPT_POSTFIELDS, maar houd er rekening mee dat in dit geval de gegevens worden gecodeerd met multipart/form-data.

Ik gebruik deze functie met API’s die verwachten dat gegevens worden gecodeerd met application/x-www-form-urlencoded. Daarom gebruik ik http_build_query().

Antwoord 4, autoriteit 3%

Ik raad je aan om het open-sourcepakket guzzlete gebruiken dat volledig getest is en gebruikmaakt van de nieuwste codeerpraktijken.

Guzzle installeren

Ga naar de opdrachtregel in je projectmap en typ de volgende opdracht (ervan uitgaande dat je de pakketbeheerder componistgeïnstalleerd). Als je hulp nodig hebt bij het installeren van Composer, moet je hier kijken.

php composer.phar require guzzlehttp/guzzle

Guzzle gebruiken om een POST-verzoek te verzenden

Het gebruik van Guzzle is heel eenvoudig omdat het een lichtgewicht objectgeoriënteerde API gebruikt:

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

Antwoord 5, autoriteit 2%

Ik zou graag wat gedachten willen toevoegen over het op krullen gebaseerde antwoord van Fred Tanrikut. Ik weet dat de meeste van hen al in de bovenstaande antwoorden zijn geschreven, maar ik denk dat het een goed idee is om een antwoord te geven dat ze allemaal samen omvat.

Hier is de klasse die ik heb geschreven om HTTP-GET/POST/PUT/DELETE-verzoeken te maken op basis van curl, met betrekking tot zowat de hoofdtekst van de reactie:

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;
    }
}

Verbeteringen

http_build_query gebruiken om de query-string uit een request-array te halen. (je zou ook de array zelf kunnen gebruiken, zie daarom: http://php.net/manual/en/function.curl-setopt.php)
Het antwoord teruggeven in plaats van het te herhalen. Trouwens, je kunt de terugkeer vermijden door de regel curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);te verwijderen. Daarna is de geretourneerde waarde een boolean (true = aanvraag was succesvol, anders is er een fout opgetreden) en wordt het antwoord herhaald.
Zie: http://php.net/en/manual/function.curl-exec .php
Reinig het sluiten van sessies en het verwijderen van de curl-handler door curl_closete gebruiken. Zie: http://php.net/manual/en/function.curl-close .php
Booleaanse waarden gebruiken voor de functie curl_setoptin plaats van een willekeurig getal. (Ik weet dat elk getal dat niet gelijk is aan nul ook als waar wordt beschouwd, maar het gebruik van waar genereert een beter leesbare code, maar dat is gewoon mijn mening)
Mogelijkheid om HTTP-PUT/DELETE-aanroepen te doen (handig voor het testen van RESTful-services)

Voorbeeld van gebruik

KRIJGEN

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

POST

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

PUT

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

VERWIJDEREN

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

Testen

Je kunt ook coole servicetests maken door deze eenvoudige les te gebruiken.

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

Antwoord 6, autoriteit 2%

Er is een andere CURL-methode als je die kant op gaat.

Dit is vrij eenvoudig als je eenmaal doorhebt hoe de PHP curl-extensie werkt, door verschillende vlaggen te combineren met setopt()-aanroepen. In dit voorbeeld heb ik een variabele $xml die de XML bevat die ik heb voorbereid om te verzenden – ik ga de inhoud daarvan posten in de testmethode van het voorbeeld.

$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

Eerst hebben we de verbinding geïnitialiseerd, dan stellen we enkele opties in met SetOpt (). Deze vertellen PHP dat we een postverzoek maken en dat we er wat gegevens mee bezoeken, de gegevens leveren. De vlag van de Curlopt_Returntransfer vertelt Curl om ons de output te geven als de retourwaarde van Curl_Exec in plaats van het uit te voeren. Dan maken we de oproep en sluiten we de verbinding – het resultaat is in $ reactie.

Antwoord 7, Autoriteit 2%

Als u in ieder geval WordPress gebruikt om uw app te ontwikkelen (het is eigenlijk een handige manier om autorisatie, info-pagina’s enz. Zelfs voor zeer eenvoudige dingen te krijgen), kunt u het volgende fragment gebruiken:

$response = wp_remote_post( $url, array('body' => $parameters));
if ( is_wp_error( $response ) ) {
    // $response->get_error_message()
} else {
    // $response['body']
}

Het gebruikt verschillende manieren om het daadwerkelijke HTTP-verzoek te maken, afhankelijk van wat er op de webserver beschikbaar is. Voor meer informatie, zie de HTTP API-documentatie .

Als u geen aangepast thema of plug-in wilt ontwikkelen om de WordPress-engine te starten, kunt u gewoon het volgende doen in een geïsoleerd PHP-bestand in de WordPress-root:

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

Het geeft geen thema of uitvoer alle HTML, hack weg met de WordPress API’s!

Antwoord 8, Autoriteit 2%

Nog een alternatief van de krulmoetsen hierboven is om de inheemse Stream Functies:

stream_context_create():

Creëert en retourneert een streamcontext met alle opties die zijn opgegeven in de voorinstelling opties.
stream_get_contents():

Identiek aan file_get_contents(), behalve dat stream_get_contents()werkt op een reeds open stream-bron en de resterende inhoud in een string retourneert, tot maxlengthbytes en beginnend bij de opgegeven offset.

Een POST-functie met deze kan eenvoudig zo zijn:

<?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;
}

Antwoord 9

Hier gebruikt u slechts één opdracht zonder cURL. Super simpel.

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

Antwoord 10

De betere manier om GETof POSTaanvragen met PHPis zoals hieronder:

<?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;
    }
?>

De code is afkomstig van de officiële documentatie hier http: //docs.php. NET / MANUAL / DA / HTTPREQUEST.SEND.PHP

Antwoord 11

Ik was op zoek naar een soortgelijk probleem en vond een betere aanpak van dit te doen. Dus hier gaat het.

U kunt eenvoudig de volgende regel plaatsen op de pagina Omleidingen (zeg pagina1.php).

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

Ik heb dit nodig om postverzoeken voor rust API-oproepen toe. Deze oplossing kan doorverwijzen met postgegevens en aangepaste kopwaarden.

Hier is de referentielink .

Antwoord 12

Probeer Pear’s http_request2 pakket om eenvoudig postverzoeken te verzenden. Als alternatief kunt u PHP’s krulfuncties gebruiken of een PHP streamcontext gebruiken .

HTTP_REQUEST2 maakt het ook mogelijk om te bespotten Server , zodat u uw code gemakkelijk kunt geven

Antwoord 13

[bewerken]: negeer, niet beschikbaar in PHP.

Er is nog een die u

kunt gebruiken

<?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);
?>

Klik hier voor details

Antwoord 14

Gebaseerd op het hoofdantwoord, hier is wat ik gebruik:

function do_post($url, $params) {
    $options = array(
        'http' => array(
            'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
            'method'  => 'POST',
            'content' => $params
        )
    );
    $result = file_get_contents($url, false, stream_context_create($options));
}

Voorbeeld Gebruik:

do_post('https://www.google-analytics.com/collect', 'v=1&t=pageview&tid=UA-xxxxxxx-xx&cid=abcdef...');

Antwoord 15

Ik geef de voorkeur aan deze:

function curlPost($url, $data = NULL, $headers = []) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5); //timeout in seconds
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
    curl_setopt($ch, CURLOPT_ENCODING, 'identity');
    if (!empty($data)) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    }
    if (!empty($headers)) {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }
    $response = curl_exec($ch);
    if (curl_error($ch)) {
        trigger_error('Curl Error:' . curl_error($ch));
    }
    curl_close($ch);
    return $response;
}

Gebruiksvoorbeeld:

$response=curlPost("http://my.url.com", ["myField1"=>"myValue1"], ["myFitstHeaderName"=>"myFirstHeaderValue"]);

Hoe verzend ik een POST-verzoek met PHP?