Pregunta ¿Cómo envío una solicitud POST con PHP?


En realidad, quiero leer los contenidos que vienen después de la consulta de búsqueda, cuando está hecho. El problema es que la URL solo acepta POST métodos, y no toma ninguna medida con GET método...

Tengo que leer todos los contenidos con la ayuda de domdocument o file_get_contents(). ¿Hay algún método que me permita enviar parámetros con POST método y luego leer los contenidos a través de PHP?


526
2018-04-13 10:06


origen


Respuestas:


Método sin CURL 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);

Consulte el manual de PHP para obtener más información sobre el método y cómo agregar encabezados, por ejemplo:


1045
2017-07-07 10:27



Intenté este y está funcionando bien ... como lo requiero ...

<?php
$url = $file_name;
$fields = array(
            '__VIEWSTATE'=>urlencode($state),
            '__EVENTVALIDATION'=>urlencode($valid),
            'btnSubmit'=>urlencode('Submit')
        );

//url-ify the data for the POST
foreach($fields as $key=>$value) { $fields_string .= $key.'='.$value.'&'; }
$fields_string = rtrim($fields_string,'&');

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

//execute post
$result = curl_exec($ch);
print $result;
?>

67
2018-04-15 12:15



Utilizo la siguiente función para publicar datos usando curl. $ data es una matriz de campos para publicar (se codificará correctamente usando http_build_query). Los datos están codificados usando 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 menciona que http_build_query puede omitirse ya que curl codificará correctamente la matriz pasada al parámetro CURLOPT_POSTFIELDS, pero tenga en cuenta que en este caso los datos se codificarán utilizando multipart / form-data.

Uso esta función con API que esperan que los datos se codifiquen usando application / x-www-form-urlencoded. Es por eso que uso http_build_query ().


41
2018-01-27 19:16



Te recomiendo que uses el paquete de código abierto engullir que está totalmente probado y utiliza las últimas prácticas de codificación.

Instalando Guzzle

Vaya a la línea de comando en su carpeta de proyectos y escriba el siguiente comando (suponiendo que ya tenga el administrador de paquetes) compositor instalado). Si necesita ayuda sobre cómo instalar Composer, deberías echar un vistazo aquí.

php composer.phar require guzzlehttp/guzzle

Usando Guzzle para enviar una solicitud POST

El uso de Guzzle es muy sencillo ya que usa una API ligera orientada a objetos:

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

34
2018-04-27 17:23



Hay otro método CURL si vas por ese camino.

Esto es bastante sencillo una vez que entiendes cómo funciona la extensión curl de PHP, combinando varias banderas con llamadas setopt (). En este ejemplo, tengo una variable $ xml que contiene el XML que he preparado para enviar: voy a publicar el contenido de ese método de prueba de ejemplo.

$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

Primero inicializamos la conexión, luego configuramos algunas opciones usando setopt (). Estos le dicen a PHP que estamos haciendo una solicitud posterior, y que estamos enviando algunos datos con ella, suministrando los datos. El indicador CURLOPT_RETURNTRANSFER le dice a curl que nos dé la salida como el valor de retorno de curl_exec en lugar de mostrarlo. Luego hacemos la llamada y cerramos la conexión; el resultado es $ respuesta.


20
2017-09-15 10:29



Si por casualidad está usando Wordpress para desarrollar su aplicación (en realidad es una manera conveniente de obtener autorización, páginas de información, etc. incluso para cosas muy simples), puede usar el siguiente fragmento de código:

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

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

Utiliza diferentes formas de realizar la solicitud HTTP real, dependiendo de lo que está disponible en el servidor web. Para más detalles, vea el Documentación de la API HTTP.

Si no desea desarrollar un tema o plugin personalizado para iniciar el motor de Wordpress, puede hacer lo siguiente en un archivo PHP aislado en la raíz de wordpress:

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

// ... your code

¡No mostrará ningún tema ni producirá ningún HTML, simplemente piratea con las API de Wordpress!


16
2017-10-07 08:05



Me gustaría añadir algunas reflexiones sobre la respuesta basada en curl de Fred Tanrikut. Sé que la mayoría de ellos ya están escritos en las respuestas anteriores, pero creo que es una buena idea mostrar una respuesta que los incluya a todos juntos.

Aquí está la clase que escribí para hacer peticiones HTTP-GET / POST / PUT / DELETE basadas en curl, concernientes al cuerpo de la respuesta:

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

Mejoras

  • Usando http_build_query para obtener la cadena de consulta de una matriz de solicitud. (También podría usar la matriz misma, por lo tanto, consulte: http://php.net/manual/en/function.curl-setopt.php)
  • Devolviendo la respuesta en lugar de repetirla. Por cierto, puedes evitar el regreso quitando la línea curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, verdadero);. Después de eso, el valor de retorno es un valor booleano (verdadero = la solicitud fue exitosa, de lo contrario se produjo un error) y la respuesta se repite. Ver: http://php.net/en/manual/function.curl-exec.php
  • Limpiar sesión de cierre y eliminación del curl-handler mediante el uso curl_close. Ver: http://php.net/manual/en/function.curl-close.php
  • Usar valores booleanos para curl_setopt función en lugar de usar cualquier número. (Sé que cualquier número que no sea igual a cero también se considera cierto, pero el uso de verdadero genera un código más legible, pero esa es solo mi opinión)
  • Posibilidad de realizar llamadas HTTP-PUT / DELETE (útil para pruebas de servicio RESTful)

Ejemplo de uso

OBTENER

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

ENVIAR

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

PONER

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

BORRAR

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

Pruebas

También puede hacer algunas pruebas de servicio interesantes mediante el uso de esta clase 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
2017-08-03 20:52



Estaba buscando un problema similar y encontré un mejor enfoque para hacer esto. Entonces aquí va.

Simplemente puede poner la siguiente línea en la página de redirección (digamos page1.php).

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

Necesito esto para redirigir las solicitudes de POST para DESCANSO Llamadas API Esta solución puede redirigir con datos de publicación y valores de encabezado personalizados.

Aquí está el enlace de referencia.


5
2017-12-22 06:02



Hay uno más que puedes usar

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

Haga clic aquí para obtener detalles


4
2017-10-05 08:27