En esta página

QNetworkDiskCache Class

La clase QNetworkDiskCache ofrece una caché de disco muy básica. Más información...

Encabezado: #include <QNetworkDiskCache>
CMake: find_package(Qt6 REQUIRED COMPONENTS Network)
target_link_libraries(mytarget PRIVATE Qt6::Network)
qmake: QT += network
Heredado de: QAbstractNetworkCache

Funciones públicas

QNetworkDiskCache(QObject *parent = nullptr)
virtual ~QNetworkDiskCache()
QString cacheDirectory() const
QNetworkCacheMetaData fileMetaData(const QString &fileName) const
qint64 maximumCacheSize() const
void setCacheDirectory(const QString &cacheDir)
void setMaximumCacheSize(qint64 size)

Funciones públicas reimplementadas

virtual qint64 cacheSize() const override
virtual QIODevice *data(const QUrl &url) override
virtual void insert(QIODevice *device) override
virtual QNetworkCacheMetaData metaData(const QUrl &url) override
virtual QIODevice *prepare(const QNetworkCacheMetaData &metaData) override
virtual bool remove(const QUrl &url) override
virtual void updateMetaData(const QNetworkCacheMetaData &metaData) override

Ranuras públicas

virtual void clear() override

Funciones protegidas

virtual qint64 expire()

Descripción detallada

QNetworkDiskCache almacena cada URL en su propio archivo dentro de la carpeta « cacheDirectory » utilizando QDataStream. Los archivos con un tipo MIME de texto se comprimen utilizando qCompress. Los datos solo se escriben en el disco en insert() y updateMetaData().

Actualmente no es posible compartir los mismos archivos de caché con más de una caché de disco.

QNetworkDiskCache limita por defecto la cantidad de espacio que la caché utilizará en el sistema a 50 MB.

Ten en cuenta que debes configurar el directorio de caché para que funcione.

La caché de disco de red se puede activar de la siguiente manera:

QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QNetworkDiskCache *diskCache = new QNetworkDiskCache(this);
QString directory = QStandardPaths::writableLocation(QStandardPaths::CacheLocation)
        + QLatin1StringView("/cacheDir/");
diskCache->setCacheDirectory(directory);
manager->setCache(diskCache);

Al enviar solicitudes, para controlar la preferencia de cuándo utilizar la caché y cuándo utilizar la red, ten en cuenta lo siguiente:

using namespace Qt::StringLiterals;
// do a normal request (preferred from network, as this is the default)
QNetworkRequest request(QUrl(u"http://qt-project.org"_s));
manager->get(request);

// do a request preferred from cache
QNetworkRequest request2(QUrl(u"http://qt-project.org"_s));
request2.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
manager->get(request2);

Para comprobar si la respuesta procede de la caché o de la red, se puede aplicar lo siguiente:

void replyFinished(QNetworkReply*respuesta) {
    QVariant fromCache = reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute);
    qDebug() << "page from cache?" << fromCache.toBool();
}

Consideraciones de seguridad

QNetworkDiskCache almacena en el disco los cuerpos de las respuestas HTTP y los metadatos, incluidas las cabeceras de respuesta, sin cifrar. La compresión aplicada al contenido de texto tiene como único objetivo la eficiencia en el almacenamiento y no proporciona protección de la confidencialidad.

Las respuestas que se almacenan en caché vienen determinadas principalmente por los encabezados de control de caché HTTP enviados por el servidor. Los servidores bien configurados suelen impedir el almacenamiento en caché de respuestas que contengan datos confidenciales procedentes de sesiones autenticadas. Sin embargo, la aplicación no puede dar por sentado que todos los servidores lo hagan correctamente, y lo que el servidor considere no confidencial puede no coincidir con los propios requisitos de la aplicación.

En los casos en los que la política de almacenamiento en caché del servidor no sea suficiente:

Las entradas de caché se someten a una validación estructural básica, pero pueden dejar de ser válidas debido a daños en el disco, un cierre incorrecto de la aplicación u otras causas. Las aplicaciones no deben considerar fiables los datos almacenados en caché sin una validación independiente.

Documentación de las funciones miembro

[explicit] QNetworkDiskCache::QNetworkDiskCache(QObject *parent = nullptr)

Crea una nueva caché de disco. El argumento « parent » se pasa al constructor de ` QAbstractNetworkCache`.

[virtual noexcept] QNetworkDiskCache::~QNetworkDiskCache()

Elimina el objeto de caché. Esto no borra la caché del disco.

QString QNetworkDiskCache::cacheDirectory() const

Devuelve la ubicación en la que se almacenarán los archivos en caché.

Véase también setCacheDirectory().

[override virtual] qint64 QNetworkDiskCache::cacheSize() const

Reimplementa: ` QAbstractNetworkCache::cacheSize()` const.

[override virtual slot] void QNetworkDiskCache::clear()

Reimplementa: QAbstractNetworkCache::clear().

[override virtual] QIODevice *QNetworkDiskCache::data(const QUrl &url)

Reimplementa: ` QAbstractNetworkCache::data` (const QUrl &url).

[virtual protected] qint64 QNetworkDiskCache::expire()

Limpia la caché para que su tamaño sea inferior al tamaño máximo de la caché. Devuelve el tamaño actual de la caché.

Cuando el tamaño actual de la caché es mayor que el de maximumCacheSize(), se eliminan los archivos de caché más antiguos hasta que el tamaño total sea inferior al 90 % de maximumCacheSize(), empezando por los más antiguos y utilizando la fecha de creación del archivo para determinar la antigüedad de un archivo de caché.

Las subclases pueden reimplementar esta función para cambiar el orden en que se eliminan los archivos de caché, teniendo en cuenta información de la que dispone la aplicación y de la que QNetworkDiskCache no dispone, por ejemplo, el número de veces que se ha accedido a una caché.

Nota: Las llamadas a `cacheSize()` caducan si se desconoce el tamaño actual de la caché.

Véase también ` maximumCacheSize()` y ` fileMetaData()`.

QNetworkCacheMetaData QNetworkDiskCache::fileMetaData(const QString &fileName) const

Devuelve el objeto ` QNetworkCacheMetaData ` correspondiente al archivo de caché ` fileName`.

Si fileName no es un archivo de caché, QNetworkCacheMetaData no será válido.

[override virtual] void QNetworkDiskCache::insert(QIODevice *device)

Reimplementa: QAbstractNetworkCache::insert(QIODevice *device).

qint64 QNetworkDiskCache::maximumCacheSize() const

Devuelve el tamaño máximo actual de la caché del disco.

Véase también ` setMaximumCacheSize()`.

[override virtual] QNetworkCacheMetaData QNetworkDiskCache::metaData(const QUrl &url)

Reimplementa: ` QAbstractNetworkCache::metaData` (`const QUrl &url)`.

[override virtual] QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)

Reimplementa: QAbstractNetworkCache::prepare(const QNetworkCacheMetaData &metaData).

[override virtual] bool QNetworkDiskCache::remove(const QUrl &url)

Reimplementa: ` QAbstractNetworkCache::remove` (const QUrl &url).

void QNetworkDiskCache::setCacheDirectory(const QString &cacheDir)

Establece el directorio en el que se almacenarán los archivos en caché; cacheDir

QNetworkDiskCache creará este directorio si no existe.

Los elementos de la caché preparados se almacenarán en el nuevo directorio de caché cuando se inserten.

Véase también cacheDirectory() y QStandardPaths::CacheLocation.

void QNetworkDiskCache::setMaximumCacheSize(qint64 size)

Establece el tamaño máximo de la caché de disco en size.

Si el nuevo tamaño es menor que el tamaño actual de la caché, la caché llamará a expire().

Véase también maximumCacheSize().

[override virtual] void QNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData &metaData)

Reimplementa: QAbstractNetworkCache::updateMetaData(const QNetworkCacheMetaData &metaData).

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.