Создать simpe RESTful сервис с vert.x 2.0, RxJava и mongoDB

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

• Создайте пустой проект vert.x, используя maven
• Импортируйте в IntelliJ и создайте простой HTTP-сервер
• Загрузка данных из mongoDB с помощью модуля постоянных данных vert.x mongoDB
• Выставить почтовые индексы через интерфейс REST
• Замените обратные вызовы наблюдателями RxJava

Первое, что нужно сделать, это очень просто, мы просто используем стандартный архетип Maven для создания проекта vert.x. (обратите внимание, что полный окончательный пример можно скачать с github: https://github.com/josdirksen/smartjava/tree/master/vertx-demo-1 )

Создайте пустой проект vert.x, используя maven

Перейдите в каталог, в котором вы хотите создать свой проект vert.x, введите следующее и нажмите enter:

Здесь показаны все доступные архетипы io.vertx (в данном случае только 1)

Так как есть только один, просто введите «1» и нажмите Enter. Далее он покажет вам версии, которые вы можете выбрать. Для этого примера я выбрал 2.0.1-финальную версию.

Введите «7» и нажмите Enter. Следующие шаги позволяют вам определить имя и версию вашего проекта:

Введите значения, которые вы видите выше (или используйте свои собственные), и, наконец, введите «Y», чтобы подтвердить свой выбор. Теперь будет создан проект:

Чтобы проверить, все ли прошло правильно, просто перейдите в только что созданный каталог и запустите mvn install. это загрузит все необходимые библиотеки, запустит несколько тестов и установит ваш проект в локальное хранилище maven. Теперь, когда у нас есть проект maven, мы можем загрузить его в нашу любимую среду IDE. В моем случае я использую IntelliJ, но Eclipse работает примерно так же.

Импортируйте в IntelliJ и создайте простой HTTP-сервер

Запустите IntelliJ и выберите «Файл-> Импортировать проект», перейдите в каталог, созданный maven, и импортируйте проект.

Просто нажмите «Далее» по всем вопросам, и вы получите проект внутри IntelliJ. Если вы создаете проект на основе этого архетипа, вы автоматически получаете ряд статей, с которыми можно поэкспериментировать. Несколько из них определены в заводной. IntelliJ автоматически пытается скомпилировать их, но так как он не может найти отличный компилятор, процесс компиляции / создания завершается неудачно. В этом примере мы сначала сконцентрируемся на Java-части файла vert.x, поэтому просто удалите файлы .groovy из каталога ‘src / main / resources’ и каталога ‘test / resources / интеграции_tests / groovy’.

Теперь мы можем запустить vert.x с предоставленными обработчиками напрямую через maven, установив модуль с помощью maven и затем вызвав цель ‘vertx: runModIDEA’. Обратите внимание, что вам нужно сначала вызвать mvn: compile, чтобы увидеть ваши изменения. Если вы не хотите использовать maven для запуска вашего проекта из IDE, вы также можете использовать другой подход, где вы используете класс org.vertx.java.platform.impl.cli.Starter для запуска vert.x прямо из IDE. В IntelliJ вы создаете следующую конфигурацию запуска для этого:

Если вы запустите это, вы все равно увидите ошибку. Что-то вроде этого:

Причина, по которой вы это видите, заключается в том, что в файле pom.xml, созданном архетипом vert.x, библиотеки vert.x указаны как «предоставленные». В качестве быстрого решения откройте pom.xml и измените область действия трех зависимостей io.vertx с «предоставлено» на «компилировать». Теперь, когда вы запускаете этот модуль запуска из IntelliJ, vert.x будет запускаться правильно.

Теперь, когда у нас есть настройка проекта в IntelliJ, и мы можем легко запустить его непосредственно из IDE (и перезапустить его с помощью ctrl-F5), давайте приступим к созданию простого HTTP-сервера, чтобы мы могли увидеть некоторые выходные данные из браузера для проведения тестирования. Проще (обратите внимание, что есть гораздо лучшие способы тестирования vert.x и verstitutions, чем я здесь показываю, но это кое-что для другой статьи). Откройте файл PingVerticle.java и замените метод запуска следующим кодом:

Запустите это и откройте браузер для localhost: 8888, и вы увидите следующее.

Это веб-сервер, который вы создали в vert.x и запускали прямо из вашей IDE. Кусок торта до сих пор. Теперь давайте поэкспериментируем с некоторыми данными.

Загрузка данных из mongoDB с помощью модуля постоянных данных vert.x mongoDB

Я не буду углубляться в то, как вы устанавливаете mongoDB, в Интернете достаточно статей, объясняющих это. Если вы работаете на Mac и у вас установлены macports, вы можете просто использовать следующую командную строку для установки mongoDB:

В оставшейся части этой статьи я предполагаю, что у вас установлен mongoDB, а утилиты командной строки доступны из консоли. Первое, что нам нужно сделать, это получить данные, с которыми можно поиграться. Для этого примера мы будем использовать список почтовых индексов, которые вы можете скачать с сайта mongoDB: http://media.mongodb.org/zips.json . Загрузите этот файл, откройте консоль и выполните следующую команду, чтобы сначала запустить mongoDB, а затем импортировать этот список zip-файлов в mongoDB.

Теперь мы можем использовать mongoImport для импорта загруженных почтовых индексов:

Если вы установили плагин mongoDB в IntelliJ, вы можете легко проверить, работает ли он:

На данный момент нам нужно только вызвать экземпляр mongoDB из vert.x и загрузить данные. Для этого мы будем использовать библиотеку mongodb persistor. Во-первых, нам нужно добавить этот модуль в сборку maven (обратите внимание, что это в основном для случаев, когда мы хотим отладить внутренне, vert.x разрешает сам этот модуль):

Vert.x имеет очень хорошую и интересную модульную систему (также для другой статьи), чтобы иметь возможность использовать этот моно-персистор, нам сначала нужно развернуть его как модуль. Это на самом деле довольно легко сделать:

Здесь мы загружаем конфигурацию для этого модуля, а затем вызываем deployModule с именем модуля и соответствующей частью конфигурации. Прежде всего, давайте посмотрим на конфигурацию, которую мы используем для этого:

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

к этому:

Файл config.json, содержит конфигурацию, которую мы только что показали. Таким образом, с этой настройкой у нас есть библиотека mongodb-persistor, прослушивающая адрес события по шине «mongodb-persistor». Теперь все, что осталось сделать, это отправить сообщения этой конечной точке в формате, понятном этому модулю. Для этого первого шага мы просто будем искать все почтовые индексы в состоянии «AL». Если вы посмотрите документацию https://github.com/vert-x/mod-mongo-persistor/, вы увидите, что мы сказали этому модулю «коллекцию», которую мы хотим найти, и тип «действия». мы хотим использовать. В зависимости от действия требуется дополнительная настройка. Для поиска всех почтовых индексов в состоянии ‘AL’ нам нужно создать следующее сообщение json:

Давайте изменим обработчик запроса и посмотрим на метод полного запуска:

Здесь вы можете видеть, что мы создаем правильное сообщение json, отправляем его по шине и ждем отправки ответа, пока не получим ответ от mongoDB. Мы предварительно подтверждаем этот ответ и отправляем его обратно клиенту:

Выставить почтовые индексы через интерфейс REST

Теперь, когда у нас есть базовые бэкэнд-компоненты, давайте посмотрим, что нужно для создания простого REST-интерфейса. Мы пропустим специальную фильтрацию медиатипа (я добавлю это в более позднюю статью), а пока мы просто рассмотрим HTTP-глаголы и URL-адреса. Для этой части мы хотим поддержать следующие вызовы REST:

Очень просто, но главная цель здесь — показать, как это делается, а не как вы можете создать полноценный сервис RESTful. Для обработки этих различных URL-адресов и глаголов vert.x предоставляет средство сопоставления маршрутов: (тела методов оставлены для ясности)

Для тех из вас, кто работал с такими библиотеками, как sinatra или scalatra, это будет выглядеть знакомо. Мы определяем метод, который мы хотим обработать (в этом случае получаем и публикуем), URL, который нас интересует, и обработчик, который будет вызываться при получении запроса. Как вы можете видеть в последней строке, мы передаем этот обработчик для обработки запросов на сервер, который мы создали.

Теперь давайте кратко рассмотрим реализацию этих обработчиков. Здесь мы создаем сообщения монго-персистора, которые связываются с нами с помощью mongoDB. Я не буду вдаваться в подробности этих методов, поскольку они в значительной степени говорят сами за себя:

В этом методе мы получаем все почтовые индексы из mongoDB. поскольку монго-персистор не возвращает все, что нам нужно, чтобы повторить ответ. Мы делаем это, используя следующий ReplyHandler:

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

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

Замените обратные вызовы наблюдателями RxJava

Для кода rxjava мы просто добавим пару дополнительных обработчиков, которые соответствуют другому URL. Таким образом, вместо / zips / 90210 URL будет / rxzips / 90210. Для начала добавьте следующую зависимость в вашу конфигурацию maven:

Прежде чем углубиться в то, как можно использовать rxjava и vert.x, приведем краткую цитату (с сайта rxjava), которая объясняет, почему это полезно

Java Futures просты в использовании для одного уровня асинхронного выполнения, но они начинают добавлять нетривиальную сложность, когда они вложены.

Сложно использовать Futures для оптимального составления условных асинхронных потоков выполнения (или невозможно, поскольку задержки каждого запроса меняются во время выполнения). Конечно, это можно сделать, но это быстро усложняется (и поэтому подвержено ошибкам) ​​или преждевременно блокирует Future.get (), что исключает преимущество асинхронного выполнения.

Наблюдаемые RxJava, с другой стороны, предназначены для составления потоков и последовательностей асинхронных данных.

С помощью RxJava Observables легко составлять потоки и последовательности асинхронных данных. Если вы посмотрите последние пару примеров кода из нашего примера, вы поймете, почему это было бы полезно. В последнем примере «post» у нас было три вложенных обратных вызова, с помощью наблюдаемых гораздо проще составить это и позволить коду фактически рассказать, что происходит.

Теперь давайте расширим метод post, чтобы сделать следующее:

1. сначала получить тело
2. после того, как у нас есть тело, мы обновляем элемент в базе данных
3. затем мы получаем последнюю версию из базы данных, после успешного обновления
4. после получения последней версии мы возвращаем это в ответе.

Если бы мы делали это с помощью обратных вызовов, нам, вероятно, потребовалось бы четыре вложенных уровня обратных вызовов. В rxjava мы можем сделать это следующим образом:

Все еще большой кусок кода, но большинство из них являются комментариями и вызваны тем фактом, что Java не поддерживает замыкания (пока). Так что здесь происходит?

1. Сначала мы создаем наблюдателя из запроса

   1	reqDataObservable = RxSupport.toObservable(req)

   Это означает, что мы хотим получать информацию, когда данные доступны в буфере нашего запроса.

2. Поскольку мы хотим что-то сделать с этими данными, мы используем

   1	reqDataObservable.flatMap

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

   1	rxEventBus.send

   метод. Это еще не делает вызов, но снова возвращает наблюдаемое.

3. В качестве третьего шага мы используем вывод предыдущего, чтобы (возможно) определить, было ли обновление успешным. Затем мы получаем последнюю версию из базы данных. Это еще раз сделано с использованием наблюдаемых.
4. Пока у нас нет подписчика, на самом деле ничего не происходит. Поскольку мы заинтересованы в результате последнего асинхронного действия, мы используем

   1	getLatestObservable.subscribe

   функция и ожидание (это все еще не блокирует) для результата от окончательного чтения базы данных. Как только это получено, мы отправляем ответ обратно на основе полученного сообщения.

В этом примере мы показали только пару очень маленьких частей rxjava:

• Мы использовали наблюдаемые, чтобы упростить работу и последовательность асинхронных действий.
• Мы используем функцию flatmap для передачи результата от одного асинхронного вызова в другой, и таким образом исключаем вложенные обратные вызовы
• Мы использовали расширения rxSupport и rxEventbus rxJava vert.x для простого создания наблюдаемых rxJava
• И мы начали полную последовательность, подписавшись на последнюю наблюдаемую в цепочке

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