=> Главная База Знаний Qt Написание клиент—серверных приложений на базе tcp


Написание клиент—серверных приложений на базе tcp

Классы QTcpSocket и QTcpServer могут использоваться для реализации клиентов и серверов TCP. TCP — это транспортный протокол, который составляет основу большинства прикладных протоколов сети Интернет, включая FTP и HTTP, и который может также использоваться для создания пользовательских протоколов.

TCP является потокоориентированным протоколом. Для приложений данные представляются в виде большого потока данных, очень напоминающего большой однородный файл. Протоколы высокого уровня, построенные на основе TCP, являются либо строкоориентированными, либо блокоориентированными:

• строкоориентированные протоколы передают текстовые данные построчно, завершая каждую строку символом перехода на новую строку;

• блокоориентированные протоколы передают данные в виде двоичных блоков. Каждый блок имеет в начале поле, где указан его размер, и затем идут байты данных.

Класс QTcpSocket наследует QIODevice через класс QAbstractSocket, и поэтому чтение с него или запись на него могут производиться с применением средств класса QDataStream или QTextStream. Одно существенное отличие чтения данных из сети по сравнению с чтением обычного файла заключается в том, что мы должны быть уверены в получении достаточного количества данных от партнерского узла (peer) перед использованием оператора >>. В противном случае результат может быть непредсказуемым.

В данном разделе мы рассмотрим программный код клиента и сервера, которые используют пользовательский протокол блочной передачи. Клиент называется Trip Planner (планировщик путешествий) и позволяет пользователям составлять план путешествия на поезде. Сервер называется Trip Server (сервер путешествий) и обеспечивает клиента информацией о путешествии. Мы начнем с написания клиентского приложения Trip Planner.

Приложение Trip Planner содержит поле From (из пункта), поле To (до пункта), поле Date (дата), поле Approximate Time (приблизительное время) и два переключателя, определяющие приблизительное время отправления или прибытия. Когда пользователь нажимает клавишу Search, приложение посылает запрос на сервер, который возвращает список железнодорожных рейсов, которые удовлетворяют критериям пользователя. Этот список отображается в виджете QTableWidget в окне Trip Planner. В нижней части окна расположены текстовая метка QLabel, показывающая состояние последней операции, и индикатор состояния процесса QProgressBar.

Рис. 14.1. ПриложениеТпр Planner.

Пользовательский интерфейс приложения Trip Planner был создан при помощи QtDesigner в файле tripplanner.ui. Ниже мы основное внимание уделим исходному коду подкласса QDialog, который реализует функциональность приложения:

#include "ui_tripplanner.h"

01 class TripPlanner : public QDialog, public Ui::TripPlanner

02 {

03 Q_OBJECT

04 public:

05 TripPlanner(QWidget *parent = 0);

06 private slots:

07 void connectToServer();

08 void sendRequest();

09 void updateTableWidget();

10 void stopSearch();

11 void connectionClosedByServer();

12 void error();

13 private:

14 void closeConnection();

15 QTcpSocket tcpSocket;

16 quint16 nextBlockSize;

17 };

Класс TripPlanner наследует не только QDialog, но и Ui::TripPlanner (который генерируется компилятором uic, используя файл tripplanner.ui). Переменная—член tcpSocket инкапсулирует соединение TCP. Переменная nextBlockSize используется при синтаксическом анализе блоков, поступивших с сервера.

01 TripPlanner::TripPlanner(QWidget *parent)

02 : QDialog(parent)

03 {

04 setupUi(this);

05 QDateTime dateTime = QDateTime::currentDateTime();

06 dateEdit->setDate(dateTime.date());

07 timeEdit->setTime(QTime(dateTime.time().hour(), 0));

08 progressBar->hide();

09 progressBar->setSizePolicy(QSizePolicy::Preferred,

10 QSizePolicy::Ignored);

11 tableWidget->verticalHeader()->hide();

12 tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);

13 connect(searchButton, SIGNAL(clicked()),

14 this, SLOT(connectToServer()));

15 connect(stopButton, SIGNAL(clicked()), this, SLOT(stopSearch()));

16 connect(&tcpSocket, SIGNAL(connected()),

17 this, SLOT(sendRequest()));

18 connect(&tcpSocket, SIGNAL(disconnected()),

19 this, SLOT(connectionClosedByServer()));

20 connect(&tcpSocket, SIGNAL(readyRead()),

21 this, SLOT(updateTableWidget()));

22 connect(&tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),

23 this, SLOT(error()));

24 }

В конструкторе мы инициализируем поля редактирования даты и времени текущей датой и временем. Мы также не показываем индикатор состояния программы, потому что он необходим только при активном соединении. В Qt Designer свойства minimum и maximum индикатора состояния устанавливались в 0. Это определяет поведение QProgressBar как индикатора занятости вместо стандартного индикатора, показывающего процент выполнения работы.

В конструкторе мы также связываем сигналы connected(), disconnected(), readyRead() и error(QAbstractSocket::SocketError) класса QTcpSocket с закрытыми слотами.

01 void TripPlanner::connectToServer()

02 {

03 tcpSocket.connectToHost("tripserver.zugbahn.de", 6178);

04 tableWidget->setRowCount(0);

05 searchButton->setEnabled(false);

06 stopButton->setEnabled(true);

07 statusLabel->setText(tr("Connecting to server..."));

08 progressBar->show();

09 nextBlockSize = 0;

10 }

Слот connectToServer() выполняется, когда пользователь нажимает клавишу Search для запуска процедуры поиска. Мы вызываем функцию connectToHost() объекта типа QTcpSocket для подсоединения к серверу, который, как мы предполагаем, доступен через порт 6178 по вымышленному адресу хоста tripserver.zugbahn.de. (Если вы собираетесь проверить работу этого примера на вашей машине, замените имя хоста на QHostAddress::LocalHost.) Вызов connectToHost() выполняется асинхронно; эта функция всегда немедленно возвращает управление. Соединение обычно устанавливается позже. Объект QTcpSocket генерирует сигнал connected(), если соединение успешно осуществлено и действует, или error(QAbstractSocket::SocketError), если соединение завершилось неудачей.

Затем мы обновляем интерфейс пользователя, в частности делаем видимым индикатор состояния приложения.

Наконец, мы устанавливаем переменную nextBlockSize на 0. Эта переменная содержит длину следующего блока, полученного от сервера. Мы задали значение 0, поскольку еще не знаем размер следующего блока.

01 void TripPlanner::sendRequest()

02 {

03 QByteArray block;

04 QDataStream out(&block, QIODevice::WriteOnly);

05 out.setVersion(QDataStream::Qt_4_1);

06 out << quint16(0) << quint8('S') << fromComboBox->currentText()

07 << toComboBox->currentText() << dateEdit->date()

08 << timeEdit->time();

09 if (departureRadioButton->isChecked()) {

10 out << quint8('D');

11 } else {

12 out << quint8('A');

13 }

14 out.device()->seek(0);

15 out << quint16(block.size() - sizeof(quint16));

16 tcpSocket.write(block);

17 statusLabel->setText(tr("Sending request..."));

18 }

Слот sendRequest() выполняется, когда объект QTcpSocket генерирует сигнал connected(), уведомляя об установке соединения. Задача этого слота — сгенерировать запрос к серверу с передачей всей введенной пользователем информации.

Запрос является двоичным блоком следующего формата:

• quint16 — размер блока в байтах (не учитывая данное поле),

• quint8 — тип запроса (всегда «S»),

• QString — пункт отправления,

• QString — пункт прибытия,

• QDate — дата поездки,

• QTime — примерное время отправления или прибытия,

• quint8 — признак времени отправления («D») или прибытия («А»).

Сначала мы записываем данные в массив типа QByteArray с именем block. Мы не можем писать данные непосредственно в QTcpSocket, поскольку мы не знаем размер блока, который будет отсылаться первым, пока не разместим все данные в блоке.

Сначала мы записываем 0 в поле размера блока и затем размещаем остальные данные. Затем мы делаем вызов seek(0) для устройства ввода—вывода (для установки на начало буфера QBuffer, создаваемого автоматически классом QDataStream), чтобы встать на начало массива байтов и переписать первоначальный 0 фактическим размером блока данных. Эта величина рассчитывается как размер блока за вычетом sizeof(quint16) (то есть 2), чтобы исключить поле с размером блока из общей суммы байтов. После этого мы вызываем функцию write() для объекта QTcpSocket, чтобы отослать этот блок на сервер.

01 void TripPlanner::updateTableWidget()

02 {

03 QDataStream in(&tcpSocket);

04 in.setVersion(QDataStream::Qt_4_1);

05 forever {

06 int row = tableWidget->rowCount();


07 if (nextBlockSize == 0) {

08 if (tcpSocket.bytesAvailable() < sizeof(quint16))

09 break;

10 in >> nextBlockSize;

11 }

12 if (nextBlockSize == 0xFFFF) {

13 closeConnection();

14 statusLabel->setText(tr("Found %1 trip(s)").arg(row));

15 break;

16 }

17 if (tcpSocket.bytesAvailable() < nextBlockSize)

18 break;


19 QDate date;

20 QTime departureTime;

21 QTime arrivalTime;

22 quint16 duration;

23 quint8 changes;

24 QString trainType;


25 in >> date >> departureTime >> duration >> changes >> trainType;

26 arrivalTime = departureTime.addSecs(duration * 60);

27 tableWidget->setRowCount(row + 1);

28 QStringList fields;

29 fields << date.toString(Qt::LocalDate)

30 << departureTime.toString(tr("hh:mm"))

31 << arrivalTime.toString(tr("hh:mm"))

32 << tr("%1 hr %2 min").arg(duration / 60).arg(duration % 60)

33 << QString::number(changes) << trainType;


34 for (int i = 0; i < fields.count(); ++i)

35 tableWidget->setItem(row, i, new QTableWidgetItem(fields[i]));

36 nextBlockSize = 0;

37 }

38 }

Слот updateTableWidget() подсоединяется к сигналу readyRead() класса QTcpSocket, который генерируется всякий раз при получении QTcpSocket новых данных от сервера.

Сервер пересылает нам список возможных железнодорожных рейсов, которые удовлетворяют критерию пользователя. Каждый рейс передается в виде одного блока, и каждый блок начинается с поля размера блока. Цикл forever необходим, потому что мы не обязательно получаем от сервера блоки по одному[7]. Мы можем получить целый блок или только его часть или полтора блока либо даже все блоки сразу.

Рис. 14.2. Блоки приложения Trip Server.

Итак, как действует цикл forever? Если переменная nextBlockSize равна 0, это означает, что мы не прочитали размер следующего блока. Мы пытаемся прочитать его (предполагается, что имеется по крайней мере 2 байта). Сервер использует значение 0xFFFF в поле размера блока для указания на то, что все данные переданы, и поэтому, если мы обнаруживаем это значение, мы знаем, что достигнут конец.

Если размер блока не равен 0xFFFF, мы пытаемся считать следующий блок. Во-первых, мы проверяем наличие блока байтов необходимого размера. Если его нет, мы прерываем цикл. Сигнал readyRead() будет вновь сгенерирован, когда станет доступно больше данных, и мы попытаемся повторить процедуру.

Если мы уверены, что получен целый блок, мы можем спокойно использовать оператор >> для QDataStream для извлечения относящейся к поездкам информации, и мы создаем элементы QTableWidgetItem с этой информацией. Полученный от сервера блок имеет следующий формат:

• quint16 — размер блока в байтах (не учитывая данное поле),

• QDate — дата отправления,

• QTime — время отправления,

• quint16 — длительность поездки (в минутах),

• quint8 — количество пересадок,

• QString — тип поезда.

В конце мы вновь устанавливаем переменную nextBlockSize на 0 для указания того, что размер следующего блока неизвестен и его необходимо считать.

01 void TripPlanner::closeConnection()

02 {

03 tcpSocket.close();

04 searchButton->setEnabled(true);

05 stopButton->setEnabled(false);

06 progressBar->hide();

07 }

Закрытая функция closeConnection() закрывает соединение сервера TCP и обновляет интерфейс пользователя. Она вызывается из функции updateTableWidget(), когда считывается значение 0xFFFF, и из нескольких других слотов, которые мы вскоре рассмотрим.

01 void TripPlanner::stopSearch()

02 {

03 statusLabel->setText(tr("Search stopped"));

04 closeConnection();

05 }

Слот stopSearch() подсоединяется к сигналу clicked() кнопки Stop. По существу, он просто вызывает функцию closeConnection().

01 void TripPlanner::connectionClosedByServer()

02 {

03 if (nextBlockSize != 0xFFFF)

04 statusLabel->setText(tr("Error: Connection closed by server" ));

05 closeConnection();

06 }

Слот connectionClosedByServer() подсоединяется к сигналу disconnected() объекта QTcpSocket. Если сервер закрывает соединение и мы еще не получили маркер конца, мы уведомляем пользователя о возникновении ошибки. И как обычно, мы вызываем функцию closeConnection() для обновления интерфейса пользователя.

01 void TripPlanner::error()

02 {

03 statusLabel->setText(tcpSocket.errorString());

04 closeConnection();

05 }

Слот error() подсоединяется к сигналу error(QAbstractSocket::SocketError) объекта QTcpSocket. Мы игнорируем код ошибки и используем функцию QTcpSocket::errorString(), которая возвращает понятное человеку сообщение о последней возникшей ошибке.

На этом завершается рассмотрение класса TripPlanner. Функция main() приложения Trip Planner выглядит обычным образом:

01 int main(int argc, char *argv[])

02 {

03 QApplication app(argc, argv);

04 TripPlanner tripPlanner;

05 tripPlanner.show();

06 return app.exec();

07 }

Теперь давайте реализуем сервер. Сервер состоит из двух классов: TripServer и ClientSocket. Класс TripServer наследует QTcpServer — класс, который позволяет нам принимать входящие соединения TCP. Класс ClientSocket переопределяет QTcpSocket и обслуживает одно соединение. В каждый момент времени в памяти имеется ровно столько объектов типа ClientSocket, сколько обслуживается клиентов.

01 class TripServer : public QTcpServer

02 {

03 Q_OBJECT

04 public:

05 TripServer(QObject *parent = 0);

06 private:

07 void incomingConnection(int socketId);

08 };

Класс TripServer переопределяет функцию incomingConnection() из класса QTcpServer. Данная функция вызывается всякий раз, когда клиент пытается подсоединиться к порту, который прослушивает сервер.

01 TripServer::TripServer(QObject *parent)

02 : QTcpServer (parent)

03 {

04 }

Конструктор TripServer тривиален.

01 void TripServer::incomingConnection(int socketId)

02 {

03 ClientSocket *socket = new ClientSocket(this);

04 socket->setSocketDescriptor(socketId);

05 }

В функции incomingConnection() мы создаем объект ClientSocket в качестве дочернего по отношению к объекту TripServer, и мы устанавливаем дескриптор его coкета на переданное нам значение. Объект ClientSocket автоматически удалит сам себя при прекращении соединения.

01 class ClientSocket : public QTcpSocket

02 {

03 Q_OBJECT

04 public:

05 ClientSocket(QObject *parent = 0);

06 private slots:

07 void readClient();

08 private:

09 void generateRandomTrip(const QString &from, const QString &to,

10 const QDate &date, const QTime &time);

11 quint16 nextBlockSize;

12 };

Класс ClientSocket наследует QTcpSocket и инкапсулирует состояние одного клиента.

01 ClientSocket::ClientSocket(QObject *parent)

02 : QTcpSocket(parent)

03 {

04 connect(this, SIGNAL(readyRead()), this, SLOT(readClient()));

05 connect(this, SIGNAL(disconnected()), this, SLOT(deleteLater()));

06 nextBlockSize = 0;

07 }

В конструкторе мы устанавливаем необходимые соединения сигнал—слот и задаем переменной nextBlockSize значение 0, свидетельствующее о том, что мы еще не знаем размер посланного клиентом блока.

Сигнал disconnected() подсоединяется к функции deleteLater(), которая наследуется от класса QObject, и удаляет объект после возврата управления в цикл обработки событий Qt. Это обеспечивает удаление объекта ClientSocket после закрытия сокетного соединения.

01 void ClientSocket::readClient()

02 {

03 QDataStream in(this);

04 in.setVersion(QDataStream::Qt_4_1);

05 if (nextBlockSize == 0) {

06 if (bytesAvailable() < sizeof(quint16))

07 return;

08 in >> nextBlockSize;

09 }

10 if (bytesAvailable() < nextBlockSize)

11 return;

12 quint8 requestType;

13 QString from;

14 QString to;

15 QDate date;

16 QTime time;

17 quint8 flag;

18 in >> requestType;

19 if (requestType == 'S') {

20 in >> from >> to >> date >> time >> flag;

21 srand(from.length() * 3600 + to.length() * 60 + time.hour());

22 int numTrips = rand() % 8;

23 for (int i = 0; i < numTrips; ++i)

24 generateRandomTrip(from, to, date, time);

25 QDataStream out(this);

26 out << quint16(0xFFFF);

27 }

28 close();

29 }

Слот readClient() подсоединяется к сигналу readyRead() класса QTcpSocket. Если nextBlockSize равен 0, мы начинаем считывать размер блока; в противном случае он уже считан нами, и тогда мы проверяем поступление целого блока. Если это целый блок, мы считываем его за один шаг. Мы используем QDataStream непосредственно для QTcpSocket (объект this) и считываем поля, используя оператор >>.

После чтения запроса клиента мы готовы сформировать ответ. В реальном приложении мы осуществляли бы поиск информации в базе данных расписания железнодорожных рейсов и попытались бы найти подходящие рейсы. Но здесь мы воспользуемся функцией generateRandomTrip(), которая случайным образом генерирует произвольный рейс. Мы вызываем эту функцию произвольное число раз и затем посылаем 0xFFFF для обозначения конца данных. В конце мы закрываем соединение.

01 void ClientSocket::generateRandomTrip(const QString & /* откуда */,

02 const QString & /* куда */, const QDate &date, const QTime &time)

03 {

04 QByteArray block;

05 QDataStream out(&block, QIODevice::WriteOnly);

06 out.setVersion(QDataStream::Qt_4_1);

07 quint16 duration = rand() % 200;

08 out << quint16(0) << date << time << duration << quint8(1)

09 << QString("InterCity");

10 out.device()->seek(0);

11 out << quint16(block.size() - sizeof(quint16));

12 write(block);

13 }

Функция generateRandomTrip() демонстрирует способ пересылки блока данных через соединение TCP. Это очень напоминает то, что мы делали в клиенте в функции sendRequest(). И вновь мы записываем блок в массив QByteArray таким образом, что мы можем определять его размер до того, как мы его отошлем с помощью функции write().

01 int main(int argc, char *argv[])

02 {

03 QApplication app(argc, argv);

04 TripServer server;

05 if (!server.listen(QHostAddress::Any, 6178)) {

06 cerr << "Failed to bind to port" << endl;

07 return 1;

08 }

09 QPushButton quitButton(QObject::tr("&Quit"));

10 quitButton.setWindowTitle(QObject::tr("Trip Server"));

11 QObject::connect(&quitButton, SIGNAL(clicked()),

12 &app, SLOT(quit()));

13 quitButton.show();

14 return app.exec();

15 }

В функции main() мы создаем объект TripServer и кнопку QPushButton, которая позволяет пользователю остановить сервер. Работа сервера начинается с вызова функции QTcpSocket::listen(), принимающей адрес IP и номер порта, по которому мы хотим принимать соединения. Специальный адрес 0.0.0.0 (QHostAddress::Any) соответствует наличию любого интерфейса IP на локальном хосте.

Этим завершается наш пример системы клиент—сервер. В данном случае нами использовался блокоориентированный протокол, позволяющий применять объект типа QDataStream для чтения и записи данных. Если бы мы захотели использовать строкоориентированный протокол, наиболее простым было бы применение функций canReadLine() и readLine() класса QTcpSocket в слоте, подсоединенном к сигналу readyRead():

QStringList lines;

while (tcpSocket.canReadLine())

lines.append(tcpSocket.readLine());

Мы бы затем могли обрабатывать каждую считанную строку. Пересылка данных могла бы выполняться с использованием QTextStream для QTcpSocket.

Представленная здесь реализация сервера не очень эффективна в случае, когда соединений много. Это объясняется тем, что при обработке нами одного запроса мы не обслуживаем другие соединения. Более эффективным был бы запуск нового процесса для каждого соединения. Пример Threaded Fortune Server (многопоточный сервер, передающий клиентам интересные изречения, называемые «fortunes»), расположенный в каталоге Qt examples/network/threadedfortuneserver, демонстрирует, как это можно сделать.