Qt/C++ Tutorial 080. Große Dateien mit QNetworkAccessManager herunterladen

QNetworkRequest, Qt, QNetworkAccessManager, QNetworkReply

Nach einer Frage im Forum zum Herunterladen großer Dateien mit der Qt-Bibliothek habe ich einige meiner Projekte angesprochen und ein detaillierteres Handbuch mit ähnlicher Funktionalität erstellt. Darüber hinaus hing das Problem beim Herunterladen von Dateien mit Weiterleitungen zusammen. Standardmäßig folgt QNetworkAccessManager keinen Umleitungen, um Dateien herunterzuladen und Seiten abzurufen, also müssen Sie das entsprechende Attribut in der Anfrage setzen, dann wird alles funktionieren, aber schauen wir uns alles genauer an.

Die Anwendung wird die folgende Funktionalität haben.

• QLineEdit zur Eingabe der Ziel-URL für den Download
• QLineEdit zur Eingabe des Zielverzeichnisses für den Download im ReadOnly-Modus. Wir werden es mit Hilfe von QFileDialog füllen.
• QProgressBar, der den Download-Fortschritt anzeigt
• Schaltfläche zum Abbrechen des Downloads

Unser Downloader wird so aussehen

Projektstruktur

Das Projekt besteht aus

• FileDownloader.pro - Projektprofil
• Downloader.h - Die Header-Datei der Klasse zum Herunterladen von Dateien
• Downloader.cpp - Klassenimplementierungsdatei zum Herunterladen von Dateien
• Widget.h - Header-Datei des Anwendungsfensters
• Widget.cpp - Anwendungsfenster-Implementierungsdatei
• Widget.ui - Grafische Form des Anwendungsfensters
• main.cpp - Die Datei mit der Hauptfunktion der Anwendung

FileDownloader.pro, main.cpp, Widget.ui werden nicht berücksichtigt, die ersten beiden werden standardmäßig erstellt, der letzte wird über den Grafikeditor Qt Designer erstellt, siehe im Projekt selbst, das angehängt ist zum Artikel ganz am Ende.

Widget.h

Die Header-Datei deklariert alle notwendigen Slots zum Verarbeiten von Interface-Buttons und deklariert auch die Klasse zum Herunterladen von Dateien im Stack

#ifndef WIDGET_H
#define WIDGET_H

#include "Downloader.h"

#include <QWidget>

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    // Слот для старта загрузки
    void onDownloadButtonClicked();

    // Слот для выбора каталога для скачивания
    void onSelectTargetFolderButtonClicked();

    // Слот для отмены загрузки
    void onCancelButtonClicked();

    // Слот для обновления прогресса загрузки
    void onUpdateProgress(qint64 bytesReceived, qint64 bytesTotal);

private:
    Ui::Widget *ui;
    Downloader m_downloader; // Класс для скачивания
};

#endif // WIDGET_H

Widget.cpp

#include "Widget.h"
#include "ui_Widget.h"

#include <QFileDialog>
#include <QStandardPaths>

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);
    // Подключаемся к слотам
    connect(ui->downloadPushButton, &QPushButton::clicked, this, &Widget::onDownloadButtonClicked);
    connect(ui->selectTargetFolderPushButton, &QPushButton::clicked, this, &Widget::onSelectTargetFolderButtonClicked);
    connect(ui->cancelPushButton, &QPushButton::clicked, this, &Widget::onCancelButtonClicked);
    connect(&m_downloader, &Downloader::updateDownloadProgress, this, &Widget::onUpdateProgress);
}

Widget::~Widget()
{
    delete ui;
}

void Widget::onDownloadButtonClicked()
{
    // Запускаем скачивание файла передавая в качестве аргументов
    // путь к каталогу, куда будем закачивать файлы
    // url, где находится файл
    m_downloader.get(ui->targetFolderLineEdit->text(), ui->urlLineEdit->text());
}

void Widget::onSelectTargetFolderButtonClicked()
{
    // Выбор целевого каталога для скачивания
    QString targetFolder = QFileDialog::getExistingDirectory(this,
                                                             tr("Select folder"),
                                                             QStandardPaths::writableLocation(QStandardPaths::DownloadLocation),
                                                             QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
    ui->targetFolderLineEdit->setText(targetFolder);
}

void Widget::onCancelButtonClicked()
{
    // Отмена загрузки
    m_downloader.cancelDownload();
    ui->downloadProgressBar->setMaximum(100);
    ui->downloadProgressBar->setValue(0);
}

void Widget::onUpdateProgress(qint64 bytesReceived, qint64 bytesTotal)
{
    // Обновляем прогресс загрузки
    ui->downloadProgressBar->setMaximum(bytesTotal);
    ui->downloadProgressBar->setValue(bytesReceived);
}

Downloader.h

Schauen wir uns nun die Klasse zum Herunterladen von Dateien an, wobei die Überprüfung des Download-Fortschritts berücksichtigt wird.

Ein wichtiger Punkt ist, dass große Dateien schrittweise verarbeitet werden müssen, sie können nicht in einer Anfrage gelesen werden. Daher müssen wir das QNetworkReply::readyRead -Signal vom aktuellen Request-Response-Objekt behandeln. Dieses Signal wird ausgegeben, wenn der Puffer Daten enthält, die wir lesen können.

Und erst wenn der Download abgeschlossen ist, gibt QNetworkAccessManager das Signal fertig aus, das die Datei schließt und die Verbindung mit dem Löschen des Objekts der aktuellen Antwort auf die Anfrage beendet.

#ifndef DOWNLOADER_H
#define DOWNLOADER_H

#include <QNetworkAccessManager>

class QNetworkReply;
class QFile;

class Downloader : public QObject
{
    Q_OBJECT
    using BaseClass = QObject;

public:
    explicit Downloader(QObject* parent = nullptr);

    // Метод для запуска скачиввания
    bool get(const QString& targetFolder, const QUrl& url);

public slots:
    // Метод отмены загрузки
    void cancelDownload();

signals:
    // Сигнал передающий информацию о прогрессе загрузки
    void updateDownloadProgress(qint64 bytesReceived, qint64 bytesTotal);

private slots:
    // Слот для постепенного считывания загружаемых данных
    void onReadyRead();
    // Слот для обработки завершения запроса
    void onReply(QNetworkReply* reply);

private:
    QNetworkReply* m_currentReply {nullptr};    // Текущий обрабатываемый запрос
    QFile* m_file                 {nullptr};    // Текущий файл в который идёт запись
    QNetworkAccessManager m_manager;            // Сетевой менеджер для загрузки файлов
};

#endif // DOWNLOADER_H

Downloader.cpp

#include "Downloader.h"

#include <QNetworkReply>
#include <QNetworkRequest>
#include <QFile>
#include <QDir>

Downloader::Downloader(QObject* parent) :
    BaseClass(parent)
{
    // Подключаемся к сигналу finished
    connect(&m_manager, &QNetworkAccessManager::finished, this, &Downloader::onReply);
}

bool Downloader::get(const QString& targetFolder, const QUrl& url)
{
    if (targetFolder.isEmpty() || url.isEmpty())
    {
        return false;
    }

    // Cоздаём объект класса файла для скачивания
    // здесь имеется целевая директория и имя файла, которое выделяется из URL
    m_file = new QFile(targetFolder + QDir::separator() + url.fileName());
    // Пробуем открыть файл
    if (!m_file->open(QIODevice::WriteOnly))
    {
        delete m_file;
        m_file = nullptr;
        return false;
    }

    // Создаём запрос
    QNetworkRequest request(url);
    // Обязательно разрешаем переходить по редиректам
    request.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
    // Запускаем скачивание
    m_currentReply = m_manager.get(request);

    // После чего сразу подключаемся к сигналам о готовности данных к чтению и обновлению прогресса скачивания
    connect(m_currentReply, &QNetworkReply::readyRead, this, &Downloader::onReadyRead);
    connect(m_currentReply, &QNetworkReply::downloadProgress, this, &Downloader::updateDownloadProgress);
    return true;
}

void Downloader::onReadyRead()
{
    // Если есть данные и файл открыт
    if (m_file)
    {
        // записываем их в файл
        m_file->write(m_currentReply->readAll());
    }
}

void Downloader::cancelDownload()
{
    // Отмена запроса
    if (m_currentReply)
    {
        m_currentReply->abort();
    }
}

void Downloader::onReply(QNetworkReply* reply)
{
    // По завершению запроса
    if (reply->error() == QNetworkReply::NoError)
    {
        // сохраням файл
        m_file->flush();
        m_file->close();
    }
    else
    {
        // Или удаляем его в случае ошибки
        m_file->remove();
    }

    delete m_file;
    m_file = nullptr;
    reply->deleteLater();
}

Fazit

Wir haben also eine Anwendung, die unter einer bestimmten URL die erforderliche Datei herunterladen und im Zielverzeichnis ablegen kann.

Projekt-Download-Link Downloader