Comment envoyer une requête POST avec PHP?

en fait je veux lire le contenu qui vient après la requête de recherche, quand il est fait. Le problème est que L'URL n'accepte que les méthodes POST , et ne prend aucune mesure avec la méthode GET ...

je dois lire tout le contenu à l'aide de domdocument ou file_get_contents() . Y a-t-il une méthode qui me permette d'envoyer des paramètres avec la méthode POST et de lire ensuite le contenu via PHP ?

543
demandé sur Gui Imamura 2011-04-13 14:06:00
la source

11 ответов

méthode sans boucle avec 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);

voir le manuel PHP pour plus d'informations sur la méthode et comment ajouter des en-têtes, par exemple:

1062
répondu dbau 2016-03-16 20:39:42
la source

vous pouvez utiliser 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, 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;
?>
71
répondu Fred Tanrikut 2018-10-01 06:32:40
la source

j'utilise la fonction suivante pour poster des données en utilisant curl. $data est un tableau de champs à afficher (sera correctement encodé en utilisant http_build_query). Les données sont encodées en utilisant 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 mentionne que http_build_query peut être omis puisque curl codera correctement le tableau passé au paramètre CURLOPT_POSTFIELDS, mais sachez que dans ce cas les données seront codées en utilisant multipart/form-data.

j'utilise cette fonction avec les API qui s'attendent à ce que les données soient encodées en utilisant application/x-www-form-urlencoded. C'est pourquoi j'utilise http_build_query().

46
répondu Dima L. 2018-03-25 19:24:20
la source

je vous recommande d'utiliser le paquet open-source guzzle qui est entièrement testé à l'unité et utilise les dernières pratiques de codage.

Installation De Guzzle

allez à la ligne de commande dans votre dossier de projet et tapez la commande suivante (en supposant que vous avez déjà le gestionnaire de paquets composer installé). Si vous avez besoin d'aide pour installer Composer, vous devriez jetez un oeil ici .

php composer.phar require guzzlehttp/guzzle

utilisant Guzzle pour envoyer une demande postale

L'usage de Guzzle est très simple car il utilise une API légère orientée objet:

// 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);
35
répondu Andreas 2017-05-23 14:55:07
la source

il y a une autre méthode de bouclage si vous allez par là.

c'est assez simple une fois que vous obtenez votre tête autour de la façon dont L'extension PHP curl fonctionne, en combinant divers drapeaux avec les appels setopt (). Dans cet exemple, j'ai une variable $xml qui contient le XML que j'ai préparé à envoyer - je vais poster le contenu de cette méthode de test de example.

$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

nous avons d'abord initialisé la connexion, puis nous avons défini quelques options à l'aide de setopt(). Ces dire à PHP que nous faisons une requête post, et qui nous envoyant des données, en fournissant les données. Le drapeau CURLOPT_RETURNTRANSFER indique à curl de nous donner la sortie comme valeur de retour de curl_exec plutôt que de la diffuser. Puis nous faisons l'appel et fermons la connexion - le résultat est en $réponse.

20
répondu Josip Ivic 2016-10-10 11:57:11
la source

si par hasard vous utilisez Wordpress pour développer votre application (c'est en fait un moyen pratique d'obtenir une autorisation, des pages d'information, etc même pour des choses très simples), vous pouvez utiliser le snippet suivant:

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

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

il utilise différentes façons de faire la requête HTTP réelle, en fonction de ce qui est disponible sur le serveur web. Pour plus de détails, consultez la documentation de L'API HTTP .

si vous ne voulez pas développer une thème ou plugin pour démarrer le moteur Wordpress, vous pouvez simplement faire ce qui suit dans un fichier PHP isolé dans la racine de wordpress:

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

// ... your code

il ne montrera aucun thème ou sortie tout HTML, il suffit de pirater avec les API Wordpress!

17
répondu 2015-10-07 11:05:44
la source

j'aimerais ajouter quelques réflexions sur la réponse de Fred Tanrikut basée sur la boucle. Je sais que la plupart d'entre eux sont déjà écrits dans les réponses ci-dessus, mais je pense que c'est une bonne idée de montrer une réponse qui comprend tous ensemble.

Voici la classe que j'ai écrite pour faire des requêtes HTTP-GET/POST/PUT/DELETE basées sur curl, concernant à peu près le corps de la réponse:

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

améliorations

  • à l'Aide de http_build_query pour extraire la chaîne de requête d'un tableau request.(vous pouvez également utiliser le tableau lui-même, donc voir: http://php.net/manual/en/function.curl-setopt.php )
  • renvoie la réponse au lieu de la faire écho. Btw vous pouvez éviter le retour en supprimant la ligne curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); . Après cela la valeur de retour est un booléen (true = la requête a été réussie sinon une erreur s'est produite) et la réponse s'est fait l'écho. Voir: http://php.net/en/manual/function.curl-exec.php
  • Propre session de clôture et la suppression de la boucle de gestionnaire à l'aide de curl_close . Voir: http://php.net/manual/en/function.curl-close.php
  • utilisant des valeurs booléennes pour la fonction curl_setopt au lieu d'utiliser n'importe quel nombre.(Je sais que tout nombre non equal zero est également considéré comme vrai, mais l'usage de true génère un code plus lisible, mais ce n'est que mon avis)
  • possibilité de faire des appels HTTP-PUT/DELETE (utile pour les tests de service RESTful)

exemple d'usage

GET

$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"));

supprimer

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

test

vous pouvez également faire quelques tests de service cool en utilisant cette classe simple.

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}]');
    }
}
12
répondu mwatzer 2018-03-06 12:00:07
la source

une autre alternative de la méthode sans boucle au-dessus de est d'utiliser le "natif 1519100920" stream fonctions:

  • stream_context_create() :

    crée et renvoie un contexte de flux avec n'importe quelle option fournie dans options preset.

  • stream_get_contents() :

    identique à file_get_contents() , sauf que stream_get_contents() fonctionne sur un flux déjà ouvert ressource et retourne les contenus restants dans une chaîne, jusqu'à maxlength octets et à partir du spécifié offset .

une fonction de poste avec ceux-ci peuvent simplement être comme ceci:

<?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;
}
6
répondu CPHPython 2018-04-20 13:05:27
la source

je cherchais un problème similaire et j'ai trouvé une meilleure approche pour le faire. Donc, ici, il va.

vous pouvez simplement mettre la ligne suivante sur la page de redirection (dites page1.php).

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

j'en ai besoin pour rediriger les requêtes POST pour les appels API REST . Cette solution est capable de rediriger avec des données post ainsi que des valeurs d'en-tête personnalisées.

Voici le lien de référence .

5
répondu Arindam Nayak 2016-07-13 15:47:30
la source

il y en a un de plus que vous pouvez utiliser""

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

Cliquez ici pour plus de détails

4
répondu Code 2015-10-05 11:27:44
la source

essayez le paquet HTTP_Request2 de PEAR pour envoyer facilement des requêtes postales. Vous pouvez aussi utiliser les fonctions curl de PHP ou utiliser un PHP stream context .

HTTP_Request2 permet également de se moquer du serveur, de sorte que vous pouvez tester votre code à l'unité facilement

1
répondu cweiske 2017-05-23 15:03:05
la source

Autres questions sur php http post request