via - php simulate post




Come invio una richiesta POST con PHP? (8)

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

Questo è abbastanza semplice una volta che hai capito come funziona l'estensione di curl PHP, combinando vari flag con le chiamate setopt (). In questo esempio ho una variabile $ xml che contiene l'XML che ho preparato da inviare - inserirò il contenuto di questo nel metodo di test di 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

Per prima cosa 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 invece di emetterlo. Quindi effettuiamo la chiamata e chiudiamo la connessione: il risultato è in $ response.

In realtà voglio leggere i contenuti che arrivano dopo la query di ricerca, quando è finito. Il problema è che l'URL accetta solo i metodi POST e non intraprende alcuna azione con il metodo GET ...

Devo leggere tutti i contenuti con l'aiuto di domdocument o file_get_contents() . C'è qualche metodo che mi permetterà di inviare parametri con il metodo POST e quindi leggere i contenuti tramite PHP ?


Ce n'è un altro 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


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

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


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

HTTP_Request2 consente anche di prendere in giro il server, in modo da poter testare facilmente il tuo codice


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

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

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

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

Se non desideri sviluppare un tema o un plug-in personalizzato per avviare il motore Wordpress, puoi semplicemente eseguire le seguenti operazioni in un file PHP isolato nella radice wordpress:

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

// ... your code

Non mostrerà alcun tema o non produrrà alcun HTML, ma sfrutterà le API di WordPress!


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

Puoi semplicemente mettere la seguente riga sulla 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 API REST . Questa soluzione è in grado di reindirizzare con i dati dei post, nonché i valori di intestazione personalizzati.

Ecco il link di riferimento .


Vi consiglio di usare il guzzle pacchetto open-source che è completamente testato e usa le ultime pratiche di codifica.

Installazione Guzzle

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

php composer.phar require guzzlehttp/guzzle

Usare Guzzle per inviare una richiesta POST

L'utilizzo 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);

Vorrei aggiungere alcune considerazioni sulla risposta a ricciolo di Fred Tanrikut. So che molti di loro sono già stati 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 fare richieste HTTP-GET / POST / PUT / DELETE basate su curl, riguardo al 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

  • Usando http_build_query per estrarre la stringa di query da un array di richieste. (Potresti anche usare l'array stesso, quindi vedi: php.net/manual/en/function.curl-setopt.php )
  • Restituire la risposta invece di farla eco. Btw puoi evitare il ritorno rimuovendo la riga curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, true); . Successivamente, il valore restituito è un valore booleano (true = la richiesta ha avuto esito positivo 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 curl-handler usando curl_close . Vedi: http://php.net/manual/en/function.curl-close.php
  • Usando valori booleani per la funzione curl_setopt invece di usare qualsiasi numero. (So che qualsiasi numero diverso da zero è considerato vero, ma l'uso di true genera un codice più leggibile, ma questa è solo la mia opinione)
  • Possibilità di effettuare chiamate HTTP-PUT / DELETE (utile per test di 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

È inoltre possibile eseguire alcuni test di servizio interessanti utilizzando 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}]');
    }
}




request