Come posso inviare una richiesta POST con PHP?

In realtà voglio leggere i contenuti che vengono dopo la query di ricerca, quando è fatto. Il problema è che l'URL accetta solo POSTmetodi e non esegue alcuna azione con il GETmetodo ...

Devo leggere tutti i contenuti con l'aiuto di domdocumento file_get_contents(). Esiste un metodo che mi consente di inviare parametri con POSTmetodo e quindi di leggere i contenuti tramite PHP?

Metodo CURL-less con 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);

Consulta il manuale di PHP per ulteriori informazioni sul metodo e su come aggiungere le intestazioni, ad esempio:

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

Puoi usare 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, 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;
?>

Uso la seguente funzione per pubblicare i dati usando l'arricciatura. $ data è un array di campi da pubblicare (sarà codificato correttamente usando http_build_query). I dati vengono codificati utilizzando 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 menziona che http_build_query può essere omesso poiché il ricciolo codificherà correttamente l'array passato al parametro CURLOPT_POSTFIELDS, ma si ricorda che in questo caso i dati verranno codificati usando multipart / form-data.

Uso questa funzione con le API che prevedono la codifica dei dati mediante application / x-www-form-urlencoded. Ecco perché uso http_build_query ().

Ti consiglio di usare il guzzle del pacchetto open source che è completamente testato dall'unità e utilizza le ultime pratiche di codifica.

Installazione di Guzzle

Vai alla riga di comando nella cartella del tuo progetto e digita il seguente comando (supponendo che tu abbia già installato il compositore del gestore pacchetti ). Se hai bisogno di aiuto su come installare Composer, dovresti dare un'occhiata qui .

php composer.phar require guzzlehttp/guzzle

Utilizzo di Guzzle per inviare una richiesta POST

L'uso di Guzzle è molto semplice in quanto utilizza un'API orientata agli oggetti leggera:

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

C'è un altro metodo CURL se stai andando in quel modo.

Questo è piuttosto semplice una volta che hai la testa sul modo in cui funziona l'estensione PHP curl, combinando vari flag con chiamate setopt (). In questo esempio ho una variabile $ xml che contiene l'XML che ho preparato per l'invio - pubblicherò il contenuto di questo nel metodo di test dell'esempio.

$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

Inizialmente abbiamo inizializzato la connessione, quindi abbiamo impostato alcune opzioni usando setopt (). Questi dicono a PHP che stiamo facendo una richiesta di posta e che stiamo inviando alcuni dati con esso, fornendo i dati. Il flag CURLOPT_RETURNTRANSFER dice a curl di darci l'output come valore di ritorno di curl_exec anziché emetterlo. Quindi effettuiamo la chiamata e chiudiamo la connessione - il risultato è in $ response.

Se per caso stai usando Wordpress per sviluppare la tua app (in realtà è un modo conveniente per ottenere autorizzazioni, pagine di informazioni ecc. Anche per cose molto semplici), puoi usare il seguente frammento:

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

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

Utilizza diversi modi per effettuare la richiesta HTTP effettiva, a seconda di ciò che è disponibile sul server web. Per ulteriori dettagli, consultare la documentazione dell'API HTTP .

Se non vuoi sviluppare un tema o plugin personalizzato per avviare il motore di Wordpress, puoi semplicemente fare quanto segue in un file PHP isolato nella radice di wordpress:

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

// ... your code

Non mostrerà alcun tema o non produrrà alcun HTML, basta tagliare via con le API di Wordpress!

Vorrei aggiungere alcune riflessioni sulla risposta a base di ricci di Fred Tanrikut. So che molti di loro sono già scritti nelle risposte sopra, ma penso che sia una buona idea mostrare una risposta che li includa tutti insieme.

Ecco la classe che ho scritto per effettuare richieste HTTP-GET / POST / PUT / DELETE in base al ricciolo, concernente solo il corpo della risposta:

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

miglioramenti

• Utilizzo di http_build_query per estrarre la stringa di query da un array di richieste (è possibile utilizzare anche l'array stesso, quindi consultare: http://php.net/manual/en/function.curl-setopt.php )
• Restituisce la risposta invece di farla eco. Tra l'altro puoi evitare il ritorno rimuovendo la riga curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, true); . Dopodiché il valore restituito è un valore booleano (true = richiesta eseguita correttamente altrimenti si è verificato un errore) e la risposta viene ripetuta. Vedi: http://php.net/en/manual/function.curl-exec.php
• Pulisci la chiusura della sessione e la cancellazione del gestore ricciolo usando curl_close . Vedi: http://php.net/manual/en/function.curl-close.php
• Usare valori booleani per la funzione curl_setopt invece di usare qualsiasi numero (so che qualsiasi numero diverso da zero è anche considerato vero, ma l'uso di vero genera un codice più leggibile, ma questa è solo la mia opinione)
• Possibilità di effettuare chiamate HTTP-PUT / DELETE (utile per il test del servizio RESTful)

Esempio di utilizzo

OTTENERE

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

INVIARE

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

METTERE

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

ELIMINA

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

analisi

Puoi anche fare dei fantastici test di servizio usando questa semplice classe.

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

Un'altra alternativa del metodo senza arricciatura sopra è utilizzare le funzioni di flusso native :

• stream_context_create():

  Crea e restituisce un contesto di flusso con qualsiasi opzione fornita nelle opzioni predefinite.

• stream_get_contents():

  Identico a file_get_contents(), tranne che stream_get_contents() opera su una risorsa di flusso già aperta e restituisce i contenuti rimanenti in una stringa, fino a byte di massima lunghezza e a partire dall'offset specificato .

Una funzione POST con questi può essere semplicemente così:

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

Il modo migliore di inviare GETo POSTrichiedere PHPè come di seguito:

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

Il codice è tratto dalla documentazione ufficiale qui http://docs.php.net/manual/da/httprequest.send.php

Ce n'è ancora uno che puoi usare

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

Clicca qui per i dettagli

Stavo cercando un problema simile e ho trovato un approccio migliore per farlo. Quindi eccolo qui.

Puoi semplicemente inserire la seguente riga nella pagina di reindirizzamento (ad esempio pagina1.php).

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

Ho bisogno di questo per reindirizzare le richieste POST per le chiamate all'API REST . Questa soluzione è in grado di reindirizzare con i dati dei post e i valori di intestazione personalizzati.

Ecco il link di riferimento .

Qui sta usando solo un comando senza cURL. Super semplice.

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

Prova il pacchetto HTTP_Request2 di PEAR per inviare facilmente richieste POST. In alternativa, è possibile utilizzare le funzioni di arricciatura di PHP o utilizzare un contesto di flusso PHP .

HTTP_Request2 consente anche di deridere il server , in modo da poter testare l'unità facilmente il codice