Una aplicación minimalista para listar fuentes RSS
Una demostración de cómo recuperar y mostrar un recurso de red.
Este ejemplo muestra cómo recuperar un recurso solicitado por el usuario y mostrar los datos contenidos en la respuesta, ilustrado mediante una aplicación de listado RSS. (RDF Site Summary, o Really Simple Syndication, es un formato estándar para comunicar actualizaciones en sitios web. Para más detalles, consulta https://www.rssboard.org/rss-specification.) La interfaz de usuario de la ilustración es sencilla, ya que este ejemplo se centra en cómo utilizar la red, pero, naturalmente, para un lector de RSS serio se necesitaría una interfaz más sofisticada.
El ejemplo también ilustra cómo realizar un análisis asíncrono de los datos a medida que se reciben, conservando el estado en variables miembro para que un analizador incremental pueda procesar fragmentos de datos a medida que llegan a través de la red. Los componentes del contenido analizado pueden comenzar en un bloque de datos, pero no completarse hasta un bloque posterior, lo que requiere que el analizador conserve el estado entre llamadas.

El programa principal es bastante sencillo. Simplemente crea una instancia de ` QApplication ` y del widget ` RSSListing `, muestra este último y cede el control al primero. A modo de ejemplo, le proporciona al widget la URL del blog de Qt como valor por defecto para el recurso que debe comprobar.
int main(int argc, char **argv)
{
QApplication app(argc, argv);
RSSListing rsslisting(u"https://www.qt.io/blog/rss.xml"_s);
rsslisting.show();
return app.exec();
}La clase RSSListing
class RSSListing : public QWidget
{
Q_OBJECT
public:
explicit RSSListing(const QString &url = QString(), QWidget *widget = nullptr);
public slots:
void fetch();
void finished(QNetworkReply *reply);
void consumeData();
void error(QNetworkReply::NetworkError);
private:
void parseXml();
void get(const QUrl &url);
// Parser state:
QXmlStreamReader xml;
QString currentTag;
QString linkString;
QString titleString;
// Network state:
QNetworkAccessManager manager;
QNetworkReply *currentReply;
// UI elements:
QLineEdit *lineEdit;
QTreeWidget *treeWidget;
QPushButton *fetchButton;
};El propio widget ofrece una interfaz de usuario sencilla para especificar la URL que se va a recuperar y, una vez que se muestran las actualizaciones disponibles, para controlar la descarga de los elementos actualizados. Un QLineEdit permite introducir la URL, y un QTreeWidget muestra los resultados una vez recuperados.
El widget descarga y analiza el RSS (un formato de XML) de forma asíncrona, enviando los datos a un lector de XML a medida que llegan. Esto permite leer fuentes de datos de gran tamaño. Dado que los datos se transmiten desde la red a través del lector de XML, no es necesario conservar el texto completo del XML en memoria. En otro contexto, un enfoque similar puede permitir al usuario interrumpir dicha carga incremental.
Construcción
RSSListing::RSSListing(const QString &url, QWidget *parent)
: QWidget(parent), currentReply(0)
{
connect(&manager, &QNetworkAccessManager::finished, this, &RSSListing::finished);
lineEdit = new QLineEdit(this);
lineEdit->setText(url);
connect(lineEdit, &QLineEdit::returnPressed, this, &RSSListing::fetch);
fetchButton = new QPushButton(tr("Fetch"), this);
connect(fetchButton, &QPushButton::clicked, this, &RSSListing::fetch);
treeWidget = new QTreeWidget(this);
connect(treeWidget, &QTreeWidget::itemActivated,
// Open the link in the browser:
this, [](QTreeWidgetItem *item) { QDesktopServices::openUrl(QUrl(item->text(1))); });
treeWidget->setHeaderLabels(QStringList { tr("Title"), tr("Link") });
treeWidget->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
QHBoxLayout *hboxLayout = new QHBoxLayout;
hboxLayout->addWidget(lineEdit);
hboxLayout->addWidget(fetchButton);
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addLayout(hboxLayout);
layout->addWidget(treeWidget);
setWindowTitle(tr("RSS listing example"));
resize(640, 480);
}El constructor configura los distintos componentes del widget y conecta sus diversas señales a las ranuras que utilizará para gestionarlas.
La interfaz de usuario consta de un campo de edición, un botón y un widget de vista de lista. El campo de edición se utiliza para introducir la URL de la que se van a recuperar las actualizaciones; el botón inicia el proceso de recuperación de actualizaciones. El campo de edición está vacío por defecto, pero quien llama al constructor puede anularlo, tal y como ha hecho nuestro ` main() `. En cualquier caso, el usuario puede sustituir la URL predeterminada por la de otra fuente RSS.
La vista de lista muestra los elementos actualizados que aparecen en la fuente RSS. Al hacer doble clic en uno de ellos, se envía su URL al navegador del usuario u otro agente de usuario mediante QDesktopServices::openUrl().
Las ranuras
void RSSListing::fetch()
{
lineEdit->setReadOnly(true);
fetchButton->setEnabled(false);
treeWidget->clear();
get(QUrl(lineEdit->text()));
}
void RSSListing::consumeData()
{
int statusCode = currentReply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (statusCode >= 200&& statusCode < 300)
parseXml();
}
void RSSListing::error(QNetworkReply::NetworkError)
{
qWarning("error retrieving RSS feed");
xml.clear();
currentReply->disconnect(this);
currentReply->deleteLater();
currentReply = nullptr;
}
void RSSListing::finished(QNetworkReply*respuesta)
{
Q_UNUSED(respuesta);
lineEdit->setReadOnly(false);
fetchButton->setEnabled(true);
}Todas las ranuras se mantienen sencillas delegando cualquier tarea compleja a métodos privados.
Cuando el usuario termina de introducir una URL, ya sea haciendo clic en el botón «Fetch» o pulsando la tecla Intro en el campo de edición, la ranura « fetch() » desactiva el botón «Fetch» e impide seguir editando el campo de edición. Borra la visualización de las actualizaciones disponibles y delega en « get() » la iniciación de una solicitud HTTP GET.
Cuando se reciben los datos, la respuesta de red activa su señal « readyRead()», que « get() » conecta al slot « consumeData() ». Este comprueba si la respuesta ha recibido un código de estado de éxito y, en caso afirmativo, llama a « parseXml() » para consumir los datos.
Si la respuesta de la red presenta un error, este se envía a la ranura error(), que notifica el error, borra el lector de flujos XML, se desconecta de la respuesta y la elimina.
Una vez completada (ya sea con éxito o no) una respuesta de red, el slot « finished() » restablece la interfaz de usuario para que esté lista para aceptar una nueva URL que recuperar, reactivando el campo de texto y el botón «Fetch».
El método get()
void RSSListing::get(const QUrl &url)
{
if (currentReply) {
currentReply->disconnect(this);
currentReply->deleteLater();
}
currentReply = url.isValid() ? manager.get(QNetworkRequest(url)) : nullptr;
if (currentReply) {
connect(currentReply, &QNetworkReply::readyRead, this, &RSSListing::consumeData);
connect(currentReply, &QNetworkReply::errorOccurred, this, &RSSListing::error);
}
xml.setDevice(currentReply); // Equivalent to clear() if currentReply is null.
}El método privado ` get() ` es utilizado por el slot ` fetch() ` para iniciar una solicitud HTTP GET. En primer lugar, borra el lector de flujo XML y, si hay una respuesta activa en ese momento, la desconecta y la elimina. Si la URL que se le ha pasado es válida, solicita al gestor de acceso a la red que realice una solicitud GET. Conecta sus ranuras pertinentes a las señales de la respuesta resultante (si la hay) y configura su lector de flujo XML para leer los datos de la respuesta; un objeto de respuesta de red es también un ` QIODevice`, del que se pueden leer datos.
El método parseXml()
void RSSListing::parseXml()
{
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name()== u"item") {
linkString = xml.attributes().value("rss:about").toString();
titleString.clear();
}
currentTag = xml.name().toString();
} else if (xml.isEndElement()) {
if (xml.name()== u"item") {
QTreeWidgetItem*item = new QTreeWidgetItem;
item->setText(0, titleString);
item->setText(1, linkString);
treeWidget->addTopLevelItem(item);
}
} else if (xml.isCharacters()&& !xml.isWhitespace()) {
if (currentTag== "title")
titleString+= xml.text();
else if (currentTag== "link")
linkString+= xml.text();
}
}
if (xml.error()&& xml.error() != QXmlStreamReader::PrematureEndOfDocumentError)
qWarning() << "XML ERROR:" << xml.lineNumber() << ": " << xml.errorString();
}Cuando se reciben datos, y por lo tanto están disponibles para el lector de flujos XML, « parseXml() » lee el flujo XML, buscando elementos « item » y, dentro de ellos, elementos « title » y « link ». Utilizará el atributo « rss:about » de un elemento « item » como URL en la columna «Link» de la vista de árbol; en su defecto, utilizará el contenido de su elemento « link »; y utilizará el contenido del elemento « title » en la columna «Title» de la vista de árbol. A medida que se cierra cada elemento ` item `, sus detalles se convierten en una nueva fila en el widget de árbol, con el título y la URL extraídos en las columnas «Título» y «Enlace».
Las variables que controlan el estado del análisis — linkString, titleString y currentTag — son variables de miembro de la clase RSSListing, aunque solo se acceda a ellas desde este método, ya que este puede llamarse repetidamente a medida que llegan nuevos datos, y un fragmento de datos recibido puede iniciar un elemento que no se completa hasta que llega un fragmento posterior. Esto permite que el analizador funcione de forma asíncrona a medida que llegan los datos, en lugar de tener que esperar a que hayan llegado todos los datos.
Véase también QNetworkReply y QXmlStreamReader.
© 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.