LibQxt: Сигналы и слоты по сети

LibQxt: Сигналы и слоты по сети

Сигналы и слоты в Qt являются весьма удачной реализацией паттерна Наблюдатель. Однако их взаимодействие ограничено тем процессом, в котором работает приложение. И этого не всегда оказывается достаточно. Конечно, существуют различные технологии IPC (в том числе и в Qt), но они, как правило, не столь удобны и просты в использовании. Поэтому нам на помощь приходит библиотека LibQxt. Она позволяет совместить ясность сигналов/слотов и гибкость сокетов, чтобы ваши приложения могли взаимодействовать в сетевой среде без чрезмерных усложнений.

Перед тем как начать

Проект LibQxt не входит в стандартный пакет поставки Qt. Его нужно скачивать отдельно (например, вот тут). Кроме того, на сегодняшний день его поддержка прекращена. Проект не развивается. Возможно, когда-нибудь ситуация изменится, но сейчас могут возникнуть проблемы со сборкой под Qt 5, поэтому с LibQxt рекомендуется использовать Qt 4.

Когда вы скачаете последнюю стабильную версию LibQxt (на момент написании заметки 0.6.2), то сразу подключить ее к вашему проекту не получится. Библиотека распространяется в виде исходного кода, поэтому сначала нужно провести сборку с тем компилятором и той версией Qt, которую вы используете для собственных разработок.

Собрать LibQxt совсем не сложно. Для Linux предусмотрен скрипт configure, а для Windows configure.bat.

Сборка LibQxt под Linux

Для Linux’а команда сборки выглядит следующим образом:

Замечу, что мне под Archlinux’ом для успешного выполнения configure пришлось поменять значение переменной QMAKE_BIN внутри скрипта с qmake на qmake-qt4, но вполне возможно, что вам это не потребуется.

Кроме того, вы можете выполнить установку LibQxt в системные папки с помощью команды make install с root-правами. Это даст некоторые удобства при подключении скомпонованных библиотек к вашим проектам, но преимущества не столь существенны. К тому же я предпочитаю хранить нестандартные внешние библиотеки в репозитории системы контроля версий вместе с исходниками. Но выбор в данном случае остается за вами.

Сборка LibQxt под Windows

Для Windows с использованием компилятора msvc запуск сборки выглядит так:

Удобнее всего вводить эти строки в Visual Studio Command Prompt. Это один из инструментов Visual Stuido Tools, который представляет собой обычную консоль cmd, но с дополнительными путями в PATH и необходимыми переменными окружения. Конечно, можно было бы указать все это в ручную для системы в целом, но если, например, вы используете разные версии Qt одновременно, то это приведет к появлению загадочных сообщений об ошибках при запуске Qt-приложений, в которых они расскажут все, что о вас думают.

Что получилось?

Предположим, что мы не стали запускать make install, а ограничились командой make. Если все прошло без ошибок, то в результате сборки у нас появился каталог lib/. В этом каталоге нас будут интересовать две библиотеки: libQxtCore и libQxtNetwork. Именно они и обеспечат работу сигналов и слотов по сети. Кроме того, обратите внимание на другой каталог, расположенный рядом с lib/, который называется include/. В нем для каждого модуля имеется свой подкаталог, но h-файлов там вы не найдете. Здесь проявляется самый ощутимый недостаток отказа от установки, поскольку придется скопировать их туда из соответствующих подкаталогов src/ вручную. Необходимо перенести src/core/*.h в include/QxtCore/, а src/network/*.h в include/QxtNetwork/. Все это нам скоро понадобится.

Пишем спецификацию

Пришло время придумать задачу, которую мы будем решать с помощью LibQxt. Сложность здесь заключается в том, что пример должен быть не слишком скучным, но и не слишком сложным. Поэтому создадим клиент-серверное приложение для совместного общения, то есть очень простой чат. Идея следующая:

  1. Есть приложение-сервер, которое представляет собой обычное консольное приложение;
  2. Есть приложение-клиент, работающее в графическом режиме. В нем должно быть поле ввода сообщений и область отображения всех сообщений, отправленных в чат участниками диалога;
  3. Само собой, к серверу может подключиться множество клиентов одновременно и общаться между собой.

Проект назовем QxtChat. Тогда серверная часть будет QxtChatServer, а клиентская — QxtChatClient.

На рисунке изображены 3 запущенных экземпляра чата на фоне консоли, в которой работает серверная часть. Я собирал и запускал приложение под Archlinux’ом с графической оболочкой Openbox и отключенными декорациями окон, поэтому вид приложений может показаться несколько необычным, но это самые стандартные виджеты Qt.

По рисунку мы можем понять, что чат пока что не дает возможности представиться и связывает сообщения с уникальными числовыми идентификаторами клиентов, что на практике будет не особо удобно. Кроме того, сейчас адрес сервера жестко прошит в коде клиентов и определен значением localhost. Однако не так сложно будет вынести запрос этого значения в графический интерфейс или в конфигурационный файл. Поэтому при желании вы сами можете добавить эти возможности после того, как мы разберемся с текущей реализацией.

Реализация чата QxtChat

Сразу хочу предупредить, что я проводил сборку под Linux, но если вы работает под Windows, то разница будет минимальной. По сути все отличия сводятся к тому, что вместо суффикса linux будет использован win32. Однако я буду делать некоторые комментарии по поводу Windows-версии, где разница окажется более существенной.

Подготовка проекта

Я уже затрагивал вопрос о структуре Qt-проектов. Поэтому здесь пройдемся лишь кратко по ключевым вопросам. Дерево проекта у меня получилось таким:

Поскольку проект простой, то каталогов не очень много. В import/ я скопировал include/QxtCore/ и include/QxtNetwork/, которые мы заранее подготовили. А в lib.linux/LibQxt/ поместил файлы библиотек из каталога сборки LibQxt.

В каталоге src для исходных кодов выделены подкаталоги для каждого подпроекта и добавлен вспомогательный каталог include/ для общих заголовочных файлов (у нас он будет всего один).

QxtChat.pro

В корневом каталоге проекта создадим главный pro-файл с шаблоном subdirs и добавим в него 2 наших подпроекта:

common.pri

Добавим в корневой каталог проекта разделяемый pri-файл. Поскольку библиотеки мы в проект не включаем, то для краткости поместим в него все, что понадобится и в QxtChatClient и в QxtChatServer:

Ничего особо нового здесь мы не видим. Однако обратите внимание на то, что мы прописали в INCLUDEPATH пути к заголовочным файлам LibQxt и к нашему внутреннему src/include/. Кроме того, в QMAKE_LFLAGS для Linux-версии добавлен путь поиска библиотек LibQxt. В Windows просто скопируйте dll-ки в bin/debug/ и bin/release/.

QxtChatServer

Начнем с реализации серверной части. Вот содержимое QxtChatServer.pro, который находится в src/QxtChatServer/:

Здесь самым важным является то, что мы подключаем модуль network в первой строке. Без него LibQxt работать не будет. Кроме того, в HEADERS прописывается наш разделяемый заголовочный файл shareddefs.h из src/include/. В остальном все без сюрпризов. Обычное консольное приложение на Qt.

Теперь рассмотрим заголовочный файл qxtchatserver.h:

Для сервера мы определили соответствующий класс, который должен наследовать QObject, чтобы можно было пользоваться сигналами и слотами.

Функция-член start(), очевидно, запускает сервер и возвращает true, если это сделать удалось, иначе false.

Назначение слотов onClientConnected() и onClientDisconnected() тоже понятно из их названий. Один обрабатывает ситуацию, когда клиент устанавливает сетевое соединение, а второй срабатывает в случае, когда соединение с клиентом обрывается. В качестве параметра им передается уникальный числовой идентификатор клиента.

Еще один слот onMessageReceived() будет настроен на прием сигналов от клиентов по сети с помощью LibQxt. Он принимает два параметра: числовой идентификатор клиента и текстовое сообщение, которое отправил этот клиент.

И наконец экземпляр класса QxtRPCPeer в качестве закрытого поля m_peer. В нем и заключена та мощь LibQxt, которой мы вскоре воспользуемся. Заметим, что m_peer может работать как в режиме сервера, так и в режиме клиента.

Далее перейдем к файлу реализации qxtchatserver.cpp:

Сначала мы соединяем сигналы от m_peer с нашими слотами для контроля за подключением и отключением клиентов:

Но это стандартное соединение сигналов-слотов в Qt. А вот следующее соединение уже интереснее:

Здесь мы прикрепляем наш слот onMessageReceived() к m_peer, связывая его с помощью символьной константы SEND_MSG_TO_SERVER. Сама эта константа определена в файле src/include/shareddefs.h, о котором мы поговорим немного позже. Выбор значения константы ничем не ограничен, но в данном случае удобно рассматривать ее как имя канала передачи данных от клиента к серверу. Таким образом, вместо традиционного указателя на Qt-объект и сигнала здесь мы используем некоторый именованный канал. У класса QxtRPCPeer еще есть функция-член attachSignal(), которая позволяет аналогичным образом связывать сигналы Qt-объектов с символьными константами. В нашем приложении мы ее не используем, но вы без труда можете задействовать такую возможность при необходимости.

Далее идет реализация функции start():

Для простоты мы не ограничиваем адрес прослушивания какой-то одной сетью (например, 127.0.0.1), а разрешаем прием всех соединений. В реальном приложении может потребоваться вынести этот параметр в файл конфигурации. Запустить Qxt-сервер очень легко. Достаточно вызывать listen() нашего объекта m_peer. В качестве параметра мы передаем ему подготовленный IP, обернутый в класс QHostAddress и константу со PORT. Эта константа определена в заголовочном файле shareddefs.h. Как понятно из названия, она определяет числовое значение порта, на котором будет ожидаться прием соединений от клиентов. Ее выбор достаточно произвольный, однако следует убедиться, что этот порт не занят и его уже не использует какое-нибудь приложение в системе.

Теперь разберемся с обработкой ситуации, когда к серверу подключается новый клиент:

Сначала мы просто выводим на консоль отладочную информацию с указанием идентификатора клиента. Далее с помощью функции-члена call() отправляем сообщение новому клиенту по именованному каналу SEND_MSG_TO_CLIENT (также определенному в shareddefs.h) с приветствием. А в последней строке уведомляем подключенных ранее клиентов о том, что к нам на сервер зашел новый пользователь. Это сообщение получат все клиенты, кроме вновь подключившегося.

Аналогичным образом мы обрабатываем и ситуацию разрыва соединения с клиентом:

Выводим отладочное сообщение и отправляем всем клиентам уведомление о том, что кто-то отключился.

Слот для обработки сообщений от пользователей не намного сложнее:

В первой строке выводим полученное сообщение для отладки. А затем отправляем это сообщение всем подключенным клиентам. В том числе и тому клиенту, от которого пришло сообщение. Вообще, можно было провести небольшую оптимизацию и не отправлять сообщение тому клиенту, от которого оно пришло. Но для наших целей это не столь существенно и вы можете сами сделать описанное улучшение.

Осталось рассмотреть файл main.cpp для проекта-сервера:

Но и здесь мы не видим ничего необычного. Мы просто создаем экземпляр нашего сервера и запускаем его. Если запуск окончился неудачей, то особого смысла делать что-то еще нет, поэтому мы выводим уведомление об ошибке на консоль и завершаем работу приложения. Ну а если сервер стартовал, то обо всем остальном позаботится LibQxt.

Перед тем, как перейти к разработке клиентской части, посмотрим на константы, определенные в файле shareddefs.h:

Сейчас имена констант полностью совпадают с их текстовыми значениями, но при желании значения можно сократить в качестве незначительной оптимизации за счет уменьшения передаваемой информации. Значение порта взято совершенно случайным образом и единственное ограничение заключалось в его уникальности. Вы можете придумать свое значение, а еще лучше вынести его в конфигурационный файл.

QxtChatClient

Начнем с содержимого файла QxtChatClient.pro:

Практически то же самое, что было для сервера. Но теперь у нас графическое приложение, а не консольное. И вновь обратите внимание на подключенный модуль network. Без него LibQxt работать не будет.

Далее посмотрим на заголовочный файл нашего виджета для чата:

Пройдемся по объявлениям в этом классе по порядку. Мы переопределили виртуальную функцию- член showEvent() класса QWidget лишь для того, чтобы активировать фокус поля ввода сообщения, когда окно отобразится на экране.

Затем идут три слота:

Они предназначены для прямой связи с объектом m_peer для приема сигналов об успешном подключении и отключении от сервера, а также на случай сообщения об ошибке соединения. Код ошибки передается в параметре error и определяется в перечислении enum.

Слот appendMessage() будет использовать для присоединения сообщений к главной текстовой области чата. А слот sendMessage() является обработчиком нажатия кнопки Отправить.

Следующие два слота выполняют вспомогательную роль и предназначены для автоматического установления соединения с сервером:

Функция-член initUI() выделена для компоновки UI нашего чата. Можно было воспользоваться приложением Qt Designer, но интерфейс не настолько сложный, чтобы это было необходимо.

Среди полей класса определены элементы графического интерфейса пользователя, экземпляр класса QxtRPCPeer и логическая переменная для хранения текущего статуса соединения m_connected.

Переходим к реализации нашего виджета qxtchatwidget.cpp:

В верхней части файла мы определили две константы:

Первая определяет время в миллисекундах между попытками повторного подключения к серверу, если соединение оборвалось. А во второй мы зашили константу с адресом сервера. Конечно, для реального приложения этот параметр обязательно должен быть вынесен в конфигурационный файл с настройками.

В конструкторе класса мы вызываем функцию компоновки нашего UI. Ее реализация достаточно тривиальна, поэтому на нее мы останавливаться не будем. Далее идет соединение сигналов m_peer с нашими обработчиками подключения, отключения и ошибки сервера. Заметим, что основное отличие между сигналами disconnectedFromServer() и serverError(), которые возвращает QxtRPCPeer, заключается в том, что в первом случае мы сами закрываем соединение (с помощью disconnectServer()), а во втором либо происходит обрыв связи, либо сервер завершает свою работу (причину можно узнать в параметре error). В следующей строке определяется соединение:

Здесь практически то же самое, что было для сервера, кроме явного указания типа соединения Qt::QueuedConnection. Это сделано для того, чтобы обезопасить себя от пропуска Qxt-сообщений. Проблемы могут возникнуть, если в обработчике одного из слотов, пришедших от сервера, мы отправим обратно некий запрос и попытаемся его дождаться. Однако в нашем простом чате подобного происходить не будет, поэтому можно особо не беспокоиться.

Чтобы наш интерфейс реагировал на действия пользователя свяжем сигналы со слотами:

Отправка сообщений будет происходить при нажатии клавиши Enter в текстовом поле и в случае срабатывания кнопки Отправить.

В последней строке конструктора запускается слот refreshConnection(), чтобы выполнить попытку подключения к серверу.

В showEvent() происходит ровно то, что мы и планировали:

Логика работы слотов onConnectedToServer(), onDisconnectedFromServer() и onServerError() довольно похожа на то, что происходило на сервере ранее. Отличие здесь лишь в том, что в случае успешного подключения мы переводим состояние m_connected в true, а в случае успешного отключения в false. Если соединение завершилось не по нашему желанию, то мы вызываем слот onConnectionFailed():

В нем мы сбрасываем значение флага m_connected и откладываем запуск слота refreshConnection() по таймеру. В самом слоте refreshConnection() все довольно просто:

Если подключение еще не установлено, то вызывается метод connect() объекта m_peer по значениям SERVER_HOST, определенному выше в этом же файле, и PORT, который мы задали в shareddefs.h. Если подключение пройдет успешно, то сработает соответствующий сигнал и мы окажемся в слоте onConnectedToServer(), а если что-то пойдет не так, то мы вновь попадем в onServerError(), который приведет к еще одному запуску таймера и т.д.

Теперь посмотрим на слот отправки сообщения на сервер:

Если соединение не установлено, то мы просто выводим соответствующее сообщение на экран. Кроме того, если текст для отправки пустой, то обрабатывать тоже нечего. Сама отправка сообщения достигается с помощью функции-члена call() совершенно так же, как это делалось на сервере.

Остался последний слот в QxtChatWidget:

Он предназначен, как для вывода сообщений от сервера, так и прямого вызова на клиенте. В целом можно было бы сделать прямую привязку к слоту append() объекта m_chatView, но я решил, что для чата не помешает автопрокрутка вниз, которая по умолчанию не происходит.

Вот и все. Наш виджет чата готов. Осталось лишь вывести его на экран:

Заключение

Вот мы и рассмотрели основы работы с LibQxt. Это очень полезная и мощная сетевая библиотека. Мы затронули лишь самые-самые базовые возможности, но уже создали полноценный чат, которым с минимальными доработками можно пользоваться. Возможно, в будущем появятся другие заметки по этой теме, где мы добавим еще пару функций, которые пригодятся в большинстве приложений.

Звёзд: 1Звёзд: 2Звёзд: 3Звёзд: 4Звёзд: 5 (Пока оценок нет)
Загрузка...
Понравилась статья? Поделиться с друзьями:
Добавить комментарий