FAQ Qt

FAQ QtConsultez toutes les FAQ

Nombre d'auteurs : 26, nombre de questions : 298, dernière mise à jour : 15 juin 2021

Sommaire→Modules→Qt Network→QHttp

Comment télécharger une page Web avec QHttp ?
Comment exécuter une requête simple sur un serveur avec la méthode GET ?
Comment exécuter une requête avec envoi d'information sur un serveur avec la méthode GET ?
Comment exécuter une requête avec envoi d'informations sur un serveur avec la méthode POST ?
Comment récupérer un cookie avec QHttp ?

Version hors-ligne

Comment télécharger une page Web avec QHttp ?

Qt a encapsulé le protocole HTTP au sein de la classe QHttp. Celle-ci possède notamment les méthodes suivantes :

int post ( const QString & path, QIODevice * data, QIODevice * to = 0) : permet l'envoi de données ;
int get ( const QString & path, QIODevice * to = 0) : permet la réception des données ;
int close () : ferme la connexion.

Téléchargement d'une page Web

Cacher/Afficher le codeSélectionnez

#include <QApplication>
#include <QPushButton>
#include <QGridLayout>
#include <QProgressBar>
#include <QLabel>
#include <QLineEdit>
#include <QHBoxLayout>
#include <QHBoxLayout>
#include <QHttp>
#include <QFile>
#include <QUrl>
#include <QMessageBox>
#include <QFileDialog>

class FAQHttp : public QWidget
{
    Q_OBJECT
    QPushButton   *m_Bouton_Download; // Bouton "Download"
    QProgressBar  *m_ProgressBar;    // Sert à afficher la progression du téléchargement
    QLineEdit     *m_Edit;           // Chemin de l'URL de téléchargement
    QLabel        *m_Label;
    QHttp         *m_http;           // Permet la gestion du téléchargement via HTTP
    QFile         *m_file;           // Fichier de fin du téléchargement
    int            m_httpId;         // Contient l'ID de notre requête HTTP
public :
    FAQHttp()
    {
        // Création des contrôles de types boutons, Edit, Label, ProgressBar
        this->m_Bouton_Download = new QPushButton("Télécharger",this);
        this->m_ProgressBar = new QProgressBar(this);
        this->m_Edit = new QLineEdit(this);
        this->m_Label = new QLabel("URL:", this);
        m_Label->setBuddy(m_Edit);

        // Gestion du layout pour le placement des boutons
        QHBoxLayout *firstLayout = new QHBoxLayout;
        firstLayout->addWidget(m_Label);
        firstLayout->addWidget(m_Edit);

        QHBoxLayout *Layout = new QHBoxLayout;
        Layout->addLayout(firstLayout);
        Layout->addWidget(m_Bouton_Download);

        QVBoxLayout *secondeLayout = new QVBoxLayout();
        secondeLayout->addLayout(Layout);
        secondeLayout->addWidget(m_ProgressBar);
        setLayout(secondeLayout);

        // On connecte les différents signaux et slots pour les boutons
        connect(this->m_Bouton_Download, SIGNAL(clicked(bool)), this, SLOT(click_Download(bool)));
        resize(400, 150);//Gestion de la taille de la fenêtre
    }

private slots:

    void DownloadFile(QString source , QString fichier)
    {
        QUrl adresse(source);
        this->m_http = new QHttp(adresse.host(),80,this);
        m_file = new QFile(fichier);
        if(!m_file->open(QIODevice::WriteOnly)) // On vérifie qu'il n'y a pas de problème lors de l'ouverture du fichier
        {
            QMessageBox::information(this, "Problème HTTP", "Problème lors du téléchargement");
            // On fait le ménage en mémoire
            delete this->m_http;
            delete this->m_file;
            return;
        }
        // On effectue la requête et on en récupère l'Id
        m_httpId = m_http->get(adresse.toString(), m_file);

        // On connecte les signaux slots pour avoir l'état d'avancement du téléchargement
        connect(m_http,SIGNAL(requestFinished(int, bool)),this,SLOT(finish_download(int ,bool)));
        connect(m_http,SIGNAL(dataSendProgress(int,int)),this,SLOT(progress_download(int, int)));
        this->m_ProgressBar->reset();
        this->m_ProgressBar->setMinimum(0);
    }

    // Est déclenché à la fin du téléchargement
    void finish_download(int httpId, bool error)
    {
        if (this->m_httpId != httpId)
        {
            return;
        }
        else
        {
            if(error)
                QMessageBox::information(this, "Problème HTTP", "Problème lors du téléchargement");
            else
                QMessageBox::information(this, "HTTP", "Le téléchargement a réussi");

            this->m_file->close(); // On ferme le fichier une fois le téléchargement terminé
            // On fait le ménage au niveau mémoire
            delete this->m_http;
            delete this->m_file;
        }
    }

    // Bouton "Start" "Stop"
    void click_Download(bool valid)
    {
        QString saveFile = QFileDialog::getSaveFileName(this,"Download Files","C:\\", "All Files (*.*)");
        if(!saveFile.isEmpty())
            DownloadFile(this->m_Edit->text(),saveFile);
    }

    // Permet de suivre l'avancée du téléchargement
    void progress_download(int done , int total)
    {
        this->m_ProgressBar->setMaximum(total);
        this->m_ProgressBar->setValue(done); // On incrémente la progress bar en fonction des données téléchargées
    }

};

#include "main.moc"


int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    FAQHttp w;
    w.show();
    return a.exec();
}

Remarque 1 : cette classe possède de nombreux signaux qui permettent de suivre l'état de la connexion avec le serveur. Référez-vous à la doc pour plus d'information.

Remarque 2: depuis Qt 4.4, QHttp est déprécié au profit des classes QNetworkAccessManager et QNetworkReply, qui offrent plus de souplesse que QHttp.

Mis à jour le 7 mai 2012 par François Jaffré

Comment exécuter une requête simple sur un serveur avec la méthode GET ?

Pour exécuter une requête, nous avons besoin de deux choses : QHttp et QUrl.

QHttp permet de faire la requête proprement dite, alors que QUrl simplifie l'interaction avec les données pour se connecter au serveur (son adresse, son port ainsi que la sécurisation (HTTPS) ou non de la connexion).

Il faut aussi connecter le slot requestFinished(int, bool) afin de récupérer les données renvoyées par le serveur.

Pour simplifier le travail nous pouvons hériter de la classe QHttp afin de créer notre classe Client. Celle-ci contiendra une fonction connexion afin d'effectuer la requête.

Sélectionnez

#include <QHttp>
#include <QUrl>

class Client : public QHttp
{
Q_OBJECT

private:

    QUrl url;
    int idRequete;

public slots:

    void recuperationResultat(int id, bool error)
    {
        if ( error )
            // Il y a eu une erreur pendant la requête
            return;

        // Nous vérifions si la requête est celle que nous voulons (dans le cas où plusieurs requêtes sont en cours)
        if ( id == idRequete )
            // Ici on peut mettre un code pour récupérer les données renvoyées par le serveur dans un QByteArray
            this->readAll();
    }

public:

    Client(const QString& urlSite)
    {
        url = QUrl(urlSite); // On enregistre l'URL du site
        idRequete = 0;

        // Connexion du signal de fin de requête avec notre analyseur de résultat
        connect(this, SIGNAL(requestFinished(int, bool)), this, SLOT(recuperationResultat(int, bool)));
    }

    void connexion(void)
    {

        this->setHost  ( url.host(),
        // on détermine si c'est une connexion sécurisée
                       ( url.scheme().toLower() == "https" ) ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp,
                         url.port() == -1 ? 0 : url.port() // On détermine le port
                        );

        idRequete = this->get(url.path(),0); // La requête est lancée
    }
};

Mis à jour le 7 mai 2012 par Alexandre Laurent

Comment exécuter une requête avec envoi d'information sur un serveur avec la méthode GET ?

Pour exécuter une requête plus évoluée, nous avons besoin de trois choses : QHttp, QUrl et QHttpRequestHeader

QHttp exécute la requête proprement dite, alors que QUrl simplifie l'interaction avec les données de connexion au serveur à contacter (son adresse, son port ainsi que la sécurisation (HTTPS) ou non de la connexion). QHttpRequestHeader ajoute des informations sur notre connexion. Grâce à cette classe, nous pouvons passer des cookies ou encore changer le user-agent (qui permet d'identifier le navigateur).

Il faut aussi connecter le slot requestFinished(int, bool) afin de récupérer les données renvoyées par le serveur.

Pour simplifier le travail nous pouvons hériter de la classe QHttp afin de créer notre classe Client. Celle-ci contiendra une fonction connexion afin d'effectuer la requête.

Sélectionnez

#include <QHttp>
#include <QUrl>

class Client : public QHttp
{
Q_OBJECT

private:

    QUrl url;
    int idRequete;

public slots:

    void recuperationResultat(int id, bool error)
    {
        if ( error )
            // Il y a eu une erreur pendant la requête
            return;

        // Nous vérifions si la requête est celle que nous voulons (dans le cas où plusieurs requêtes sont en cours)
        if ( id == idRequete )
            // Ici on peut mettre un code pour récupérer les données renvoyées par le serveur dans un QByteArray
            this->readAll();
    }

public:

    Client(const QString& urlSite)
    {
        url = QUrl(urlSite); // On enregistre l'URL du site
        idRequete = 0;

        // Connexion du signal de fin de requête avec notre analyseur de résultat
        connect(this, SIGNAL(requestFinished(int, bool)), this, SLOT(recuperationResultat(int, bool)));
    }

    void connexion(void)
    {

        this->setHost  ( url.host(),
            // on détermine si c'est une connexion sécurisée
                       ( url.scheme().toLower() == "https" ) ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp,
                         url.port() == -1 ? 0 : url.port() // On détermine le port
            );

        // Ici nous créons l'entête pour notre requête
        QHttpRequestHeader reqHeader("GET", "http://qt.nokia.com");
        reqHeader.setValue("Host", "http://qt.nokia.com");
        reqHeader.setValue("User-Agent", "Nom que vous voulez");
        reqHeader.setValue("Cookie", "idducookie"); // Permet de passer un cookie pour être reconnu par le serveur

        idRequete = this->request(reqHeader);
    }
};

Si vous utilisez Firefox, et que vous ne savez pas quoi mettre dans l'en-tête, vous pouvez utiliser LiveHTTPHeaders qui affichera les informations des en-têtes envoyés et reçus par le navigateur.

Mis à jour le 7 mai 2012 par Alexandre Laurent

Lien : LiveHttpHeaders

Comment exécuter une requête avec envoi d'informations sur un serveur avec la méthode POST ?

Une requête POST permet, par exemple, de se connecter à un Site Web en envoyant un identifiant et un mot de passe.

Pour exécuter une requête POST, nous avons besoin de trois choses : QHttp, QUrl et QHttpRequestHeader

Il faut aussi connecter le slot requestFinished(int, bool) afin de récupérer les données renvoyées par le serveur.

Pour simplifier le travail nous pouvons hériter de la classe QHttp afin de créer notre classe Client. Celle-ci contiendra une fonction connexion afin d'effectuer la requête.

Sélectionnez

#include <QHttp>
#include <QUrl>

class Client : public QHttp
{
Q_OBJECT

private:

    QUrl url;
    int idRequete;

public slots:

    void recuperationResultat(int id, bool error)
    {
        if ( error )
            // Il y a eu une erreur pendant la requête
            return;

        // Nous vérifions si la requête est celle que nous voulons (dans le cas où plusieurs requêtes sont en cours)
        if ( id == idRequete )
            // Ici on peut mettre un code pour récupérer les données renvoyées par le serveur dans un QByteArray
            this->readAll();
    }

public:

    Client(const QString& urlSite)
    {
        url = QUrl(urlSite); // On enregistre l'url du site
        idRequete = 0;

        // Connexion du signal de fin de requête avec notre analyseur de résultat
        connect(this, SIGNAL(requestFinished(int, bool)), this, SLOT(recuperationResultat(int, bool)));
    }

    void connexion(void)
    {
        this->setHost  ( url.host(),
            // on détermine si c'est une connexion sécurisée
                       ( url.scheme().toLower() == "https" ) ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp,
                         url.port() == -1 ? 0 : url.port() // On détermine le port
            );

        // Prépare une chaîne qui contiendra les éléments pour la connexion
        QString searchString = QString("username=") + QString("toto") + QString("&password=") + QString("tata");

        // Ici nous créons l'en-tête pour notre requête
        QHttpRequestHeader postRequest("POST", "http://qt.nokia.com");
        postRequest.setValue("Host", "http://qt.nokia.com");
        postRequest.setValue("User-Agent", "Nom du navigateur");

        // Requête avec le passage des identifiants
        idRequete = this->request(postRequest,searchString.toUtf8());
    }
};

Si vous utilisez Firefox, et que vous ne savez pas quoi mettre dans l'en-tête, vous pouvez utiliser LiveHTTPHeaders qui affichera les informations des en-têtes envoyés et reçus par le navigateur.

Créé le 30 octobre 2009 par Alexandre Laurent

Lien : LiveHttpHeaders

Pour récupérer un cookie, nous avons besoin de quatre choses : QHttp, QUrl, QHttpRequestHeader et QHttpResponseHeader.

Il faut connecter le slot requestFinished(int, bool) afin de récupérer les données renvoyées par le serveur, et le slot responseHeaderReceived(const QHttpResponseHeader&) pour récupérer l'en-tête de réponse du serveur.

Pour simplifier le travail nous pouvons hériter de la classe QHttp afin de créer notre classe Client. Celle-ci contiendra une fonction connexion afin d'effectuer la requête.

Sélectionnez

#include <QHttp>
#include <QUrl>

class Client : public QHttp
{
Q_OBJECT

private:

    QUrl url;
    int idRequete;

public slots:

    void recuperationResultat(int id, bool error)
    {
        if ( error )
            // Il y a eu une erreur pendant la requête
            return;

        // Nous vérifions si la requête est celle que nous voulons (dans le cas où plusieurs requêtes sont en cours)
        if ( id == idRequete )
            // Ici on peut mettre un code pour récupérer les données renvoyées par le serveur dans un QByteArray
            this->readAll();
    }

    void Client :: recuperationCookie(const QHttpResponseHeader& header)
    {

        // Ce test est tiré de la norme RFC 1945
        if ( header.reasonPhrase() == QString("FOUND") && header.statusCode() >= 300 && header.statusCode() <= 399 )
        {
            // Récupération du cookie
            cookie = header.value("Set-Cookie");
        }
        else
        {
            // Il est possible que les identifiants ne soient pas bons...
        }
    }

public:

    Client(const QString& urlSite)
    {
        url = QUrl(urlSite); // On enregistre l'url du site
        idRequete = 0;

        // Connexion du signal de fin de requête avec notre analyseur de résultat
        connect(this, SIGNAL(requestFinished(int, bool)), this, SLOT(recuperationResultat(int, bool)));

        // Connexion du signal de réponse du serveur avec notre analyseur de résultat
        connect(  this, SIGNAL(responseHeaderReceived(const QHttpResponseHeader&) ),
                  this, SLOT  (recuperationCookie    (const QHttpResponseHeader&) )  );
    }

    void connexion(void)
    {

        this->setHost  ( url.host(),
        // on détermine si c'est une connexion sécurisée
                       ( url.scheme().toLower() == "https" ) ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp,
                         url.port() == -1 ? 0 : url.port() // On détermine le port
                       );

        // Prépare une chaîne qui contiendra les éléments pour la connexion
        QString searchString = QString("username=") + QString("toto") + QString("&password=") + QString("tata");

        // Ici nous créons l'en-tête pour notre requête
        QHttpRequestHeader postRequest("POST", "http://qt.nokia.com");
        postRequest.setValue("Host", "http://qt.nokia.com");
        postRequest.setValue( "User-Agent", "Nom du navigateur");

        // Requête avec le passage des identifiants
        idRequete = this->request(postRequest,searchString.toUtf8());
    }
};

Si vous utilisez Firefox, et que vous ne savez pas quoi mettre dans l'en-tête, vous pouvez utiliser LiveHTTPHeaders qui affichera les informations des en-têtes envoyés et reçus par le navigateur.

Mis à jour le 7 mai 2012 par Alexandre Laurent

Lien : LiveHttpHeaders

Version hors-ligne

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 - 2017 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.