Qt/C++ - Lektion 050. Qt-Anwendungsereignisse in einer Textdatei protokollieren

log, qDebug, Логирование, qInfo, Logger, file, qWarning, qFatal

Alle Qt-Entwickler verwenden qDebug() beim Debuggen einer Qt-Anwendung, aber es gibt auch Makros qInfo(), qWarning(), qCritical() und qFatal() (die bei der zum Zeitpunkt des Schreibens war der Artikel fehlerhaft und hat nicht funktioniert).

Mit diesen Ereignissen können Sie Fehler nach Signifikanzniveau kategorisieren und Filter anwenden, um zu trennen, welche Fehler gemeldet werden sollten und welche nicht.

Um Fehlermeldungen in eine Textdatei umzuleiten, müssen Sie den Handler CallBack-Funktion in der Anwendung installieren. Dazu wird die Funktion qInstalMessageHandler verwendet.

Die Handler-Signatur sollte wie folgt aussehen:

void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg);

Durch diese Funktion erhalten wir folgende Daten:

1. QtMsgType-Typ – Nachrichtentyp
2. QtInfoMsg
3. QtDebugMsg
4. QtWarningMsg
5. QtCriticalMsg
6. QtFatalMsg
7. QMessageLogContext &context – der Kontext der Nachricht, der nützlichste davon ist die Kategorie der Nachricht. Dies kann nützlich sein, wenn es notwendig ist, den Ort der Nachricht im Code zu bestimmen, d. h. von welchen Komponenten wir Daten erhalten oder zu welcher Art von Interaktion die Nachricht gehört.
8. QString &msg - Fehlermeldung übergeben.

Zusätzliche Kategorien – QLoggingCategory

Zusätzliche Kategorien sind Objekte der Klasse QLoggingCategory. Es kann mehrere Ansätze für die Arbeit mit Kategorien geben, zum Beispiel können wir eine Objektkategorie in einer Klasse erstellen und sie an die Fehlermeldung übergeben:

QLoggingCategory  m_category("Test");
qDebug(m_category) << "Check it";

Wir erhalten folgende Ausgabe:

Test: Check it

Der Nachteil dieses Ansatzes ist, dass mehrere Klassen die gleichen Fehlerkategorien haben können, aber in jeder Klasse die gleichen Kategorien angelegt werden müssen. Daher werden wir einen anderen Ansatz verwenden. Nämlich durch Registrieren einer Kategorie durch ein Makro.

LoggingCategories.h

Wir werden vier Kategorien in dieser Header-Klasse deklarieren.

#ifndef LOGGER_H
#define LOGGER_H

#include <QLoggingCategory>

Q_DECLARE_LOGGING_CATEGORY(logDebug)
Q_DECLARE_LOGGING_CATEGORY(logInfo)
Q_DECLARE_LOGGING_CATEGORY(logWarning)
Q_DECLARE_LOGGING_CATEGORY(logCritical)

#endif // LOGGER_H

LoggingCategories.cpp

Und weisen Sie diesen Kategorien Namen zu

#include "LoggingCategories.h"

Q_LOGGING_CATEGORY(logDebug,    "Debug")
Q_LOGGING_CATEGORY(logInfo,     "Info")
Q_LOGGING_CATEGORY(logWarning,  "Warning")
Q_LOGGING_CATEGORY(logCritical, "Critical")

LoggingCategories verwenden

Um die Kategoriedaten anzuwenden, müssen Sie die Header-Datei in die Datei einschließen, in der die Kategoriedaten verwendet werden. Und dann benutze sie:

qDebug(logDebug()) << "Check it";

Wir erhalten folgende Ausgabe:

Debug: Check it

Handler installieren

Um zu demonstrieren, wie der Handler funktioniert, verwenden wir eine grafische Anwendung mit vier Schaltflächen.

• Debuggen
• Die Info
• Warnung
• Kritisch

Im Handler jeder der Schaltflächen werden die entsprechenden Ereignisprotokollierungsmakros aufgerufen und die entsprechenden oben aufgeführten Kategorien angewendet. Das Anwendungsfenster wird von einem Grafikdesigner erstellt und sieht folgendermaßen aus.

Hauptfenster.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_debugButton_clicked();
    void on_infoButton_clicked();
    void on_warningButton_clicked();
    void on_criticalButton_clicked();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

Hauptfenster.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>

#include "LoggingCategories.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

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

void MainWindow::on_debugButton_clicked()
{
    qDebug(logDebug()) << "Debug Button";
}

void MainWindow::on_infoButton_clicked()
{
    qInfo(logInfo()) << "Info Button";
}

void MainWindow::on_warningButton_clicked()
{
    qWarning(logWarning()) << "Warning Button";
}

void MainWindow::on_criticalButton_clicked()
{
    qCritical(logCritical()) << "Critical Button";
}

main.cpp

#include "mainwindow.h"
#include <QApplication>
#include <QFile>
#include <QDir>
#include <QScopedPointer>
#include <QTextStream>
#include <QDateTime>
#include <QLoggingCategory>

// Умный указатель на файл логирования
QScopedPointer<QFile>   m_logFile;

// Объявляение обработчика
void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg);

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    // Устанавливаем файл логирования,
    // внимательно сверьтесь с тем, какой используете путь для файла
    m_logFile.reset(new QFile("C:/example/logFile.txt"));
    // Открываем файл логирования
    m_logFile.data()->open(QFile::Append | QFile::Text);
    // Устанавливаем обработчик
    qInstallMessageHandler(messageHandler);

    MainWindow w;
    w.show();

    return a.exec();
}

// Реализация обработчика
void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    // Открываем поток записи в файл
    QTextStream out(m_logFile.data());
    // Записываем дату записи
    out << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz ");
    // По типу определяем, к какому уровню относится сообщение
    switch (type)
    {
    case QtInfoMsg:     out << "INF "; break;
    case QtDebugMsg:    out << "DBG "; break;
    case QtWarningMsg:  out << "WRN "; break;
    case QtCriticalMsg: out << "CRT "; break;
    case QtFatalMsg:    out << "FTL "; break;
    }
    // Записываем в вывод категорию сообщения и само сообщение
    out << context.category << ": "
        << msg << endl;
    out.flush();    // Очищаем буферизированные данные
}

Insgesamt

Als Ergebnis der Ereignisprotokollierung wird die Datei C:\example\logFile.txt erstellt (Hinweis: Aber nur, wenn der Ordner C:\example bereits vor dem Start der Anwendung existierte).

Wenn Sie auf die Schaltflächen im Anwendungsfenster klicken, sieht der Inhalt der Datei wie folgt aus:

2016-06-04 17:05:57.439 DBG Debug: Debug Button
2016-06-04 17:05:57.903 INF Info: Info Button
2016-06-04 17:05:58.367 WRN Warning: Warning Button
2016-06-04 17:05:58.815 CRT Critical: Critical Button

Qt-Anwendung mit Protokollierung in eine Textdatei herunterladen

Videoanleitung