Как мы поняли из предыдущей лекции в этом уроке,
наша цель в этом уроке -
интегрировать уже разработанный нами REST API сервер
вместе с доступом к базе данных MongoDB.
Итак, мы начнем с сервера REST API,
который мы построили в самом первом уроке в этом модуле,
а затем научившись взаимодействовать с
нашим узловым приложением на сервер Mongoose с помощью Mongoose,
мы будем развивать наш REST API сервер для интеграции
всего путь между запросом клиента, поступающим на сервер,
вплоть до соответствующей операции базы данных, которая должна быть выполнена,
а затем построение и отправка ответа этому клиенту с нашего сайта сервера.
Чтобы начать, конечно, сначала
перейдите в папку сервера путаницы, которую мы уже создали в
самом первом упражнении этого модуля в уроке REST API,
а затем, в папке путаницы,
мы уже создали сервер REST API.
Теперь, что мы будем делать, это заимствовать
модели, которые мы разработали в предыдущем упражнении,
файл dishes.js, который мы разработали в предыдущем упражнении,
скопированный в проект сервера путаницы,
а также установить Bluebird Mongoose
и другой модуль под названием Mongoose валюту, в наш проект.
Итак, перейдя к нашей папке JS узла,
мы сначала идем в папку узла Mongoose,
и мы видим, что в подпапке моделей папки узла Mongoose,
у нас есть файл dishes.js.
Я просто скопирую папку моделей,
а затем перейду в папку сервера путаницы,
а затем просто пронзим папку моделей там.
Итак, как только мы это сделаем,
то файл dishes.js, который содержит схему и модель документа посуды,
интегрируется в наш REST API сервер.
Конечно, для того, чтобы использовать это,
нам нужно установить модуль узла Mongoose
и новый модуль узла под названием Mongoose валюты в наш проект.
Итак, перейдя на терминал в проекте сервера путаницы,
убедитесь, что ваш терминал или командное окно находится
в проекте сервера путаницы, где вы разрабатываете REST API раньше,
и в этом проекте давайте установим.
Итак, мы сделаем npm установить Mongoose,
а затем, новый модуль узла под названием Mongoose валюты.
Модуль узла валюты Mongoose
и видел в другом типе схемы для нашего приложения Mongoose,
поэтому сам Mongoose,
безусловно, уже встроенные типы схемы.
Мы видели использование числа,
строки и логического, и массива.
Теперь валюта Mongoose добавляет в поддержку валюты.
Зачем нам нужна эта валютная поддержка?
Таким образом, Mongoose валютный модуль добавляет новый тип, называемый как тип валюты,
который позволяет нам хранить значение валюты.
Поскольку наше блюдо будет содержать цену,
поэтому я собираюсь использовать валютный модуль Mongoose здесь.
Теперь, упражнение здесь,
мы проиллюстрируем использование модуля валюты Mongoose,
вы можете прочитать более подробную информацию о модуле Mongoose валюты узла также,
в документации о том, что ссылка на который предоставляется в дополнительных ресурсах.
Итак, теперь, когда мы установили эти модули узлов,
Mongoose и Mongoose валюты,
давайте перейдем к нашему приложению и настроим его для связи с сервером MongoDB.
Теперь убедитесь, что ваш сервер MongoDB работает и работает.
Итак, здесь вы видите, что
мой сервер MongoDB работает на другой вкладке терминала на моем компьютере.
Если вы используете его на компьютере с Windows,
убедитесь, что он работает в другом командном окне вашего компьютера с Windows.
Перейдя к нашему приложению в редакторе,
мы сначала начнем с файла app.js.
Теперь в файле app.js,
здесь мы создали наше экспресс-приложение ранее.
Но теперь это дополнительное отрицание сосать не подключено к серверному серверу MongoDB.
Мы будем использовать модуль Mongoose,
чтобы установить соединение с сервером.
Итак, зайдя сюда,
я собираюсь добавить модуль Mongoose здесь.
Итак, мы скажем: «Конст Мангуст требует Мангуста».
А затем, так как мы скопировали папку моделей,
в которой содержится файл блюд,
в котором объявляется схема блюд и модель.
Так что, позвольте мне импортировать посуду.
Итак, мы скажем: «Требуется. Слэш модели посуды».
Итак, как только мы завершили это, теперь, конечно,
нам нужно установить соединение с сервером.
Итак, настройте
URL mongodb// localhost7017/путаница,
как мы сделали с упражнением Mongoose,
а затем мы скажем:
«Const connect, URL-адрес подключения Монго».
Таким образом, это точно тот же код, который мы использовали в предыдущем упражнении.
Тогда давайте установим связь.
Итак, мы скажем, «connect», а затем скажем,
«DB сделать это консольный журнал».
Говоря: «Правильно подключено к серверу».
И мы также будем обрабатывать ошибку здесь.
Мы просто сделаем консольный журнал ошибки здесь, вот и все.
Это установит соединение с сервером из нашего файла app.js.
Итак, как только мы установили соединение с сервером
, то давайте откроем файл dishes.js из наших моделей.
Теперь, в файле dishes.js,
чтобы использовать
модуль узла, который мы только что установили.
Итак, мы скажем: «Требовать валюту мангуста» и скажем:
«Загрузите тип и мангуста».
Итак, что это сделает, это загрузить этот новый тип валюты в Mongoose.
После этого, мы можем сказать const,
валюта Mongoose типов валюты.
Вот оно. Итак, этот новый тип,
тип валюты добавляется в Mongoose и это добавит в новый тип, называемый
валютой, а затем я собираюсь объявить
эту постоянную валюту как валюту типов Mongoose.
Чтобы я мог использовать это при определении схемы в моем приложении.
Теперь, в этом случае,
общая схема останется точно такой же, как и раньше, но
схема блюда, как вы помните из файла db.json.
Когда вы посмотрите на структуру документа блюдо,
вы видите, что документ блюдо содержит имя и изображение, которое, как вы видите здесь, является строка,
категория,
метка, цена, которая является строковым типом здесь.
Но мы объявим это как тип валюты,
функция, которая, как вы ожидаете, является Boolean переменной,
и описание, которое является строкой, а затем комментарии,
которые не что иное, как массив типа комментариев.
Теперь, так что мы теперь сделаем, это расширить схему блюда для
поддержки всех этих различных свойств или различных полей в моем документе json.
Итак, у нас уже есть имя.
Итак, у нас уже есть описание на месте.
Поэтому нам нужно добавить в следующие несколько там у нас уже есть комментарии,
массив комментариев типа схемы комментария там.
Так что мы добавим в ближайшие несколько.
Таким образом, следующий, который мы добавим, - это тип изображения,
который будет иметь
строку типа, и
мы скажем, что требуется true.
Таким образом, это добавляет тип изображения.
Следующий, который я добавлю, - это категория,
которая также является типом строки.
Следующим является метка,
которая также является этот тип строки.
Поскольку все это одного типа и требуется,
я просто копирую их здесь.
Затем для метки
я бы сказал, что это не требуется, но
вместо этого я также могу указать значение по умолчанию, если я хочу.
Поэтому я могу указать значение по умолчанию.
Значение по умолчанию - пустая строка.
Поэтому, если я не указываю требуемое, я могу просто указать значение по умолчанию здесь.
Теперь, кроме того, следующее поле, которое я собираюсь ввести, - это ценовое поле.
Поле цены я объявлю тип как валюту.
Напомним, что мы объявляли тип валюты ранее
здесь, сначала требуя
модуль валюты Mongoose, а затем объявляя тип валюты.
Таким образом, вы бы использовали тип валюты в нашем приложении.
Таким образом, мы скажем, валюта типа цены и
требуемая правда, а затем я также могу указать минимальное значение, которое будет нулем.
Затем следующее поле является
избранное поле, которое будет иметь тип Boolean,
и значение по умолчанию будет false.
Итак, если мой документ не хватает этого,
тогда значение по умолчанию будет добавлено в документ здесь.
Поэтому обратите внимание, что теперь я расширил
схему блюда, добавив в тип изображения, категорию,
метку, цену и функцию, чтобы соответствовать
структуре документа блюдо, который я только что показал вам ранее.
Итак, моя схема посуды готова к использованию.
Итак, давайте начнем работать над моим маршрутизатором.
Так где же маршрутизатор?
Вы помните, что маршрутизатор, поддерживающий конечные точки REST API для косой черты,
конечная точка API REST и косой черты,
конечная точка идентификатора косой черты, находится в маршрутизаторе посуды.
Итак, мы перейдем к блюду router.jsfile, а затем мы расширим файл блюдо router.js.
Итак, в блюдо маршрутизатор вместе с Express и BodyParser,
я собираюсь теперь включить Mongoose.
Так что скажем, требуется Mongoose, а
затем нам потребуется модель блюд.
Где модель посуды?
Он внутри. /модель/посуда.
Значит, он там.
Поэтому обратите внимание, что мы находимся в папке маршрутизатора,
поэтому вам нужно подняться на один уровень, а затем перейти
в папку модели, а затем файл dishes.js находится прямо там.
Вот что мы импортируем здесь.
Итак, теперь я могу обновить мой маршрутизатор посуды, чтобы иметь возможность взаимодействовать
с сервером Mongoose с помощью
Mongoose, и мы уже импортировали модель блюд в мой маршрутизатор посуды.
Итак, пришло время мне пойти и обновить все методы здесь.
Так что для блюдо маршрутизатор, косая
черта, что означает, что конечная точка слэша блюда.
Я собираюсь удалить все это отсюда, вместо этого
я собираюсь явно объявить все различные конечные точки.
Чтобы получить сообщение и удалить, я буду обрабатывать каждый из них самостоятельно.
Итак, в методе get
я собираюсь вырезать это, а затем в методе get, что мне нужно сделать?
Напомним, что мы определили метод от Mongoose, который позволяет нам найти все блюда.
Поэтому, когда вы выполняете операцию get на конечной точке косой черты,
вы ожидаете, что все блюда будут возвращены
клиенту в ответ на запрос get.
Итак, я собираюсь пойти в посуду, а затем выполнить операцию поиска.
Итак, теперь вы видите, что с моего сервера Express
я получаю доступ к моему MongoDB.
Итак, будет делать находку и в находке я собираюсь теперь обрабатывать запрос.
Так что я могу сказать,
что посуда найдет, так как это вернет обещание,
тогда я смогу справиться с этим здесь.
Итак, я скажу блюдо, и поэтому, если обещание разрешится правильно,
я получу его в то время, и поэтому я скажу блюдо, а затем мы будем обрабатывать
код статуса res 200, а затем мы скажем,
тип содержимого заголовка res set.
Поскольку мы собираемся вернуть значение как json,
поэтому мы установим это для приложения json.
Хорошо, это вернет массив блюд.
Поэтому я могу просто сказать блюда, а затем мы скажем res.json.
Таким образом, res.json возьмет в качестве ввода в строку json,
а затем отправит его обратно моему клиенту.
Итак, когда вы вызываете res.json и предоставляете значение, а затем он просто
возьмет параметр, который вы даете здесь, а затем отправит его обратно в качестве ответа json.
Он поместит эти блюда в тело
ответного сообщения, а затем отправит его обратно на сервер.
Теперь мы можем обработать ошибку
здесь, сказав следующую ошибку.
Мы также можем сделать ошибку catch только ради завершения.
Я просто собираюсь поставить оба этих на место здесь,
так что оба будут обрабатываться как таковые.
Поэтому, если ошибка
возвращается, это просто передаст ошибку в
общий обработчик ошибок для моего приложения,
и пусть беспокоится о том, как справиться с ошибкой.
Так что мы отправим его на это.
Таким образом, вы видите, как я использую операцию поиска, а затем выполняю запрос здесь.
Теперь, для поста,
как вы уже ожидали,
я собираюсь сделать dishes.create,
потому что мы собираемся создать новое блюдо здесь.
Итак, напомним, что мы уже видели, что блюда создают
использование метода раньше и помните, что анализатор тела
уже проанализировал бы все, что находится в теле сообщения, и загрузил его
в свойство body запроса.
Итак, я просто собираюсь взять тело запроса, а затем проанализировать его в качестве параметра для моего
метода dises.create и обработать возвращаемое значение.
Итак, мы скажем тогда, и это вернут
блюдо, и мы разберемся с этим здесь.
Так что мы скажем, если блюда возвращаются правильно и если блюда выложены правильно, скажет res.
Хорошо, давайте сделаем console.log для нашего собственного использования.
На стороне сервера мы сделаем console.log, говорящее «блюдо создано» здесь.
Давайте запишем это блюдо на консоль, а затем мы скажем эти два кода состояния отдыха.
Мы просто скопируем этот код, а затем вставьте его туда, и в этом случае
мы возвращаем блюдо здесь.
Блюдо, которое пришло в качестве параметра здесь, а затем позволяет
клиенту иметь дело с этим значением на стороне клиента, что
бы ни было возвращено в блюдо.
Теперь, также они добавят в
это здесь, а потом улов.
Так вот как мы обрабатываем сообщение.
Для PUT, потому что PUT не допускается,
поэтому мы собираемся оставить его как таковой.
Для DELETE мы будем удалять все блюда.
Так что мы скажем: «Посуда. Уберите».
Это, по сути, опасная операция.
Таким образом, вы удаляете все блюда с
сервера, и поэтому мы скажем:
«Dishes.Remove then», и «then» получит некоторый ответ.
Поэтому мы просто скажем: «resp here», и способ, которым мы будем обрабатывать
этот ответ, - просто взять это значение, а затем вернуть его клиенту.
Таким образом, мы скажем: «res.StatusCode 200 типа содержимого application json», а
затем мы просто отправим ответ клиенту, и мы будем обрабатывать ошибку,
как мы делали ранее.
Это операция DELETE.
Таким образом, вы видите, что теперь мы выполняем
операции GET, POST, PUT и DELETE.
Теперь мы будем продолжать то же самое с конечной точкой /DishID.
Так что в этом случае,
мы специально мотив получения конкретного блюда.
Мы собираемся вернуть эту специфическую ценность блюда.
Таким образом, в GET,
то, что мы делаем, мы скажем «Dishes.FindByID.
Таким образом, findByID - это метод, который доступен из mongo, а также из драйвера MongoDB.
Так что мы скажем: «Req.params.dishid».
Напомним, что мы уже знаем, что блюдо ID присутствует в свойстве params.
Вы уже узнали об этом раньше.
Так что я скажу: «Найди ID (req.params.dishid)»,
а затем и другое.
Поэтому я просто собираюсь скопировать это тогда и еще
оттуда, а затем спуститься на DishRouter, а
затем просто вставить это здесь.
Итак, мы скажем: "Res.StatusCode200
приложение json.res.jsondish, а затем обработка ошибок.
Для POST, очевидно, мы не будем обрабатывать сообщение для конечной точки /dishID.
Так что мы оставим его как таковое.
Для PUT мы будем обновлять
конкретное блюдо, которое идентифицируется его идентификатор блюда.
Так вот, где мы будем использовать тарелы.Findbyidandupdate.
Таким образом, это метод, который мы будем использовать,
findByIDandUpdate, и это принимает в качестве первого параметра
req.params.dishid, а второе значение -
набор, и обновление
будет в теле сообщения.
Так что я просто собираюсь получить это из
тела req, а затем еще и другой флаг, который я собираюсь иметь.
Так скажем, «new: true», так что этот метод findByID вернет
обновленное блюдо как строку json в ответе.
Это то, что я собираюсь получить здесь, а затем, когда это значение придет,
я просто возьму блюдо, а
затем просто верну блюдо на стороне клиента.
Поэтому я скажу res.jason (блюдо), а затем мы будем обрабатывать ошибку соответственно.
Наконец для DELETE.
Для DELETE снова,
соответствующий метод, который мы собираемся
использовать является метод Монго под названием FindByIandRemove.
Таким образом, вы можете видеть, что у нас есть этот метод под названием
findByIandRemove, и это
findByIdAndRemove, будет принимать req.params.dishid, потому что это блюдо, которое мы пытаемся удалить.
Затем, когда это удаляется,
так же, как мы обрабатывали это здесь,
поэтому я просто собираюсь скопировать этот код из Dishes.Remove.
То же самое, что я собираюсь делать здесь тоже.
Поэтому findByIDandRemove и любой ответ, который
я получаю, я собираюсь вернуть его своему клиенту.
С этим мы обновили DishRouter.
Давайте сохраним все изменения, которые мы сделали
до сих пор, а затем мы пойдем и запустим наш сервер, а затем посмотрим, что он делает.
Таким образом, перейдя в терминал или окно команд, запустите сервер.
Поэтому я скажу «npm start», и сервер теперь работает и работает.
Мы будем использовать почтальона для связи с этим сервером.
Так что давайте пойдем к почтальона, а затем выполним определенные операции.
Вот видишь, как мой почтальон бежит сюда.
Поэтому позвольте мне выполнить операцию GET на локальном хосте: 3000/блюда.
Поэтому, когда вы выполняете операцию GET, как вы видите,
она вернет пустую строку.
Моя база данных теперь пуста, поэтому у меня ничего нет.
Поэтому я просто собираюсь вернуть пустую строку.
Давай поставим блюдо.
Поэтому, когда вы размещаете блюдо,
очевидно, в теле,
вы будете заключать блюдо, и тело будет установлено как тип json приложения.
Теперь, чтобы опубликовать блюдо,
я уже дал вам файл db.json в ресурсах упражнений.
Поэтому просто откройте файл db.json, а затем скопируйте самое первое блюдо оттуда,
а затем мы вставьте его здесь, а затем разместите это блюдо.
Итак, позвольте мне перейти к файлу db.jason.
Позвольте мне скопировать самое первое блюдо отсюда.
Так что я просто скопирую
все блюдо вплоть до туда, а потом отправлю это блюдо.
Это содержит много полей, которые у нас уже есть.
Давайте разместим это блюдо на сервере и посмотрим, что произойдет.
Так что возвращаюсь к почтальну.
Здесь, в форме данных,
в теле, позвольте мне вставить блюдо на место.
Итак, у нас есть полная информация о блюде.
Давайте POST это блюдо на сервер.
Затем, как только блюдо отправлено на сервер,
вы видите, что Почтальон имеет,
позвольте мне просто уменьшить это,
а затем вы видите внизу, что это конкретное блюдо было отправлено в базу данных, в базу данных
MongoDB моим сервером.
Итак, вы видите, что возвращаемое значение
здесь показывает, когда блюдо было вставлено на этот сервер.
Таким образом, у вас есть CreateDat и UpdateDat.
Вы видите, что все остальные поля хранятся там.
Обратите внимание, в частности, на то, как хранится цена.
Так валюта хранит стоимость цены.
Таким образом, когда вы получаете возвращаемое значение,
вам нужно правильно интерпретировать это на стороне клиента, что это означает.
Обратите внимание также, что идентификатор был добавлен в мое блюдо и для каждого самого комментария,
потому что каждый из комментариев сам по себе является вложенным документом.
У вас будут добавлены UpdateDat и CreateDat,
а идентификатор для каждого из комментариев также добавляется туда автоматически моей базой данных.
Вот ты идешь. Итак,
это блюдо добавлено в мою базу данных.
Давайте снова выполним операцию GET,
и, очевидно,
на этом этапе сервер должен вернуть это конкретное блюдо, которое было добавлено в.
Таким образом, он вернет массив блюд здесь,
так что, как вы можете видеть, он возвращает массив блюд.
Конечно, этот массив содержит только одно блюдо
, или это конкретное блюдо было возвращено сюда.
Пока что, так хорошо.
Итак, давайте сделаем PUT на посуду и посмотрим, что произойдет.
Когда вы делаете PUT, очевидно, он говорит:
«Операция PUT не поддерживается на блюдах», как мы ожидаем.
Давайте сделаем DELETE.
Выполняя операцию DELETE,
он возвращает этот ответ, говорящий:
«N равно одному», хорошо,
один означает, что он удалил одно блюдо.
Давайте теперь снова, выполним операцию GET,
и тогда вы увидите, что мои блюда пусты, как мы ожидали.
Таким образом, вы видите, что
операции GET, PUT, POST и DELETE работают правильно.
Теперь позвольте мне POST блюдо снова
на сервер, потому что я хочу иметь одно блюдо на сервере.
Итак, позвольте мне POST это блюдо,
и вы заметите, что идентификатор теперь изменился.
Итак, позвольте мне выбрать этот идентификатор,
а затем мы сделаем GET с идентификатором на месте.
Когда вы делаете GET с идентификатором на месте,
вы видите, что он возвращает это конкретное блюдо, как вы его ожидаете.
Давайте перейдем к терминалу и посмотрим, что
печатается на терминале или в вашем командном окне.
Итак, перейдя к терминалу или вашему командному окну,
вы видите, что он распечатывает все эти вещи в командном окне.
Итак, когда мы сделали первую операцию GET,
он говорит: GET /dishes.
Итак, это снова,
Морган делает эту работу для вас, он распечатывает,
отслеживает эту информацию и говорит,
что блюдо создано, а затем эта конкретная информация о блюде была напечатана,
а затем он говорит POST /блюда, GET /блюда,
а затем, когда вы сделали PUT, он вернул 403
там и вы снова создали блюда и так далее.
Итак, вы видите, что ваш сервер фактически выполняет всю работу,
и эти вещи вставляются в вашу базу данных MongoDB, как вы ожидали.
Теперь, возвращаясь к почтальну,
давайте сделаем POST на посуду.
Теперь это не поддерживается на стороне сервера,
поэтому ваш сервер должен сказать:
«Операция POST не поддерживается на этой конкретной конечной точке», как вы можете этого ожидать.
Давайте сделаем операцию PUT.
Когда вы выполняете операцию PUT,
то, что я собираюсь сделать в операции PUT, заключается
в том, что я собираюсь заменить метку там.
Итак, в моем теле сообщения.
Итак, напомним, что если вы посмотрите на файл db.json,
метка для этого будет новой,
и поэтому я собираюсь изменить эту метку на горячую.
Поскольку это должно быть в Json,
поэтому маркируйте также в кавычках Json ярлык горячий,
а затем давайте сделаем PUT на этой конкретной конечной точке.
Операция PUT была успешной,
и поэтому вы видите, что когда операция PUT была выполнена,
вы заметили, что метка теперь изменилась с нового на горячий здесь,
и обратите внимание, в частности,
значение CreateDat и значение UpdateDat.
Итак, обратите внимание, что эта запись была создана
в этот момент времени и обновлена немного позже.
Итак, обновление было сделано операцией PUT, которую я только что
выполнил на этом конкретном блюде.
Давайте удалим блюдо.
Это разрешено. Итак, мы удалим блюдо,
а затем блюдо будет удалено и значение будет возвращено.
Теперь, если вы выполняете операцию GET
на конечной точке блюд, вы увидите, что это вернет пустой.
Итак, вам просто удалось удалить блюдо из нашей базы данных.
То, что я собираюсь сделать, это выполнить
операцию GET на несуществующем блюде и посмотреть, что происходит.
Когда я выполняю операцию GET на несуществующем блюде,
он возвращает null, потому что это блюдо не существует.
Таким образом, он возвращает нулевое значение, говорящее, что блюдо не существует.
Теперь позвольте мне выполнить операцию GET на не-ObjectID и посмотреть, что происходит.
Он возвращается, как вы видите.
Позволь мне просмотреть это.
Итак, он говорит: «Cast to ObjectID не удалось получить значение здесь на пути».
Итак, я буду очевидно, что это не
действительный ObjectID, поэтому мне просто удалось удалить его часть,
а затем выполнить операцию, чтобы он вернул ошибку, сказав,
поэтому вы видите, что есть 500 внутренних ошибок сервера.
Сервер не смог справиться с этим, а затем вернуть это значение здесь.
Итак, там написано: «Нет,
это запрещено».
Таким образом, потому что это не действительный ObjectID.
Таким образом, даже ошибки обрабатываются соответствующим образом, как вы видите здесь.
Итак, позвольте мне еще раз сделать операцию GET на блюдах,
и ваш сервер все еще работает,
и он вернет пустое значение здесь.
Итак, мы видели, как, изменив
наш REST API сервер, чтобы иметь возможность взаимодействовать с сервером MongoDB.
Теперь у нас есть полноценный сервер REST API, который может хранить,
и извлекать, и выполнять различные операции с
данными, которые хранятся на моем сервере MongoDB.
С этим мы завершаем это упражнение.
Итак, в этом упражнении
мы видели, как мы можем взаимодействовать с нашим сервером REST API,
и, в свою очередь, с сервером MongoDB,
а затем мы используем сервер MongoDB для хранения и извлечения данных с сервера.
Вы можете взаимодействовать из
нашего приложения Express с сервером Mongoose с помощью Mongoose.
Это хорошее время для вас сделать фиксацию GIT с сообщением
«Express REST API с Mongoose Part One».