Создание приложений с Spring Boot
Этот урок показывает пример того, как Spring Boot помогает вам ускорить и облегчить разработку приложений. Из учебных материалов вы увидите случаи использования Spring Boot. Если вы хотите создать проект на его основе, то посетите Spring Initializr, заполните онформацию о проекте, выберите опции и вы сможете загрузить файл сборки Maven, либо Gradle, либо как проект в виде zip-файла.
Что вы создадите
Вы создадите простое web-приложение с Spring Boot и добавите в него несколько полезных сервисов.
Что вам потребуется
Как проходить этот урок
Как и большинство уроков по Spring, вы можете начать с нуля и выполнять каждый шаг, либо пропустить базовые шаги, которые вам уже знакомы. В любом случае, вы в конечном итоге получите рабочий код.
Чтобы начать с нуля, перейдите в Настройка проекта.
Настройка проекта
Для начала вам необходимо настроить базовый скрипт сборки. Вы можете использовать любую систему сборки, которая вам нравится для сборки проетов Spring, но в этом уроке рассмотрим код для работы с Gradle и Maven. Если вы не знакомы ни с одним из них, ознакомьтесь с соответсвующими уроками Сборка Java-проекта с использованием Gradle или Сборка Java-проекта с использованием Maven.
Создание структуры каталогов
Создание файла сборки Gradle
Ниже представлен начальный файл сборки Gradle. Файл pom.xml находится здесь. Если вы используете Spring Tool Suite (STS), то можете импортировать урок прямо из него.
Spring Boot gradle plugin предоставляет множество удобных возможностей:
Узнайте, что вы можете делать с Spring Boot
Spring Boot предлагает быстрый путь для создания приложений. Он просматривает ваш classpath и бины, которые вы сконфигурировали, делает предположения о том, что нехватает и добавляет их. С Spring Boot вы можете сконцентрироваться больше на решении бизнес задач и меньше на инфраструктуру.
Это лишь несколько примеров, которые предоставляет автоманическая настройка Spring Boot. В то же время, Spring Boot не заработает с вашими настройками. Например, если Thymeleaf в вашем classpath, то Spring Boot добавит SpringTemplateEngine в ваш контекст приложения автоматически. Но если вы определите свой собственный SpringTemplateEngine с вашими настройками, то Spring Boot не добавит его. Это останется под вашим контролем и потребует от вас немного усилий.
Создание простого web приложения
Теперь вы можете создать web контроллер для простого web приложения.
Создание Application класса
Здесь вы создаете Application класс с компонентами:
Метод main() используется Spring Boot методом SpringApplication.run() для запуска приложения. Вы обратили внимание, что нет ни одной строчки на XML? Файла web.xml нет вообще. Это приложение на 100% из чистой Java и вы ничего не делали для настройки какого-либо инструмента или инфраструктуры.
Метод run() возвращает ApplicationContext и этому приложению отдаются все бины, которые были созданы вашим приложением или автоматически добавлены благодаря Spring Boot. Метод сортирует бины и печатает их имена.
Запуск приложения
Для запуска приложения выполните:
Если вы используете Maven, то:
Вы должны увидеть примерно такое:
Добавление сервисов бизнес-уровня
Если вы создаете web-сайт для вашего бизнеса, то вам скорее всего необходимо добавить некоторые сервисы для управления. Spring Boot предоставляет несколько таких «из коробки» в одном из своих модулей, таких как состояние, аудит, бины и другие.
Добавьте это в список зависимостей вашего файла сборки:
Если вы используете Maven, то добавьте это в список зависимостей:
Затем перезапустите приложение:
Если вы используете Maven, то:
Вы увидите новый набор RESTful точек выхода, добавленных в приложение. Это сервисы управления, предоставленные Spring Boot:
это легко проверить по состоянию приложения:
Вы можете попытаться вызвать завершение работы через curl:
Т.к. мы не включили его, запрос блокирован, потому что его не существует.
Просмотр Spring Boot starters
Последний пример показал как Spring Boot упрощает инициализацию бинов, о которых вы не знаете, что они вам нужны. И он показал, как подклюсить удобные для управления сервисы.
ко всему прочему, Spring Boot поддерживает Groovy, позволяя вам создавать Spring MVC приложения в небольшом и единственном файле.
Создайте новый файл app.groovy и поместите в него приведенный ниже код:
Давайте проверим, что получилось:
Spring Boot динамически добавляет аннотации к вашему коду и использует Groovy Grape для подтягивания необходимых для запуска приложения библиотек. Смотрите документацию, если хотите копнуть шлубже.
Поздравляем! Вы только что создали простое web приложени с использованием Spring Boot и изучили как нарастить ваш темп разработки. вы также настроили некоторые удобные сервисы. Это только малая часть того, что может делать Spring Boot.
Spring boot: маленькое приложение для самых маленьких
В этой статье мы научимся создавать простые REST приложения. Напишем свое приложение с использованием SpringBoot, создадим свои контроллеры, воспользуемся JPA, подключим PostgreSQL.
Мы будем разрабатывать приложение в 3 этапа:
Создадим и запустим простое REST приложение на SpringBoot
Напишем приложение с сущностями, создадим контроллеры и подключим JPA
Создадим сущности и репозиторий
Напишем сервисную часть приложения
Запустим и протестируем наше приложение, удивимся, что все работает и порадуемся, что провели время с пользой и узнали что-то новое
1. Создадим и запустим простое REST приложение на SpringBoot
Мы пойдем по простому пути, а точнее зайдем на сайт-стартер проектов на SpringBoot: https://start.spring.io/. Выберем сборку gradle + Java. Запустим и соберем проект локально. Для этого через консоль используем команды, и ждем пока погдрузятся все библиотечки и соберется проект.
./gradlew wrapper — загрузка нужной версии wrapper.
Когда мы используем утилиту gradlew (по сути это оболочка, которая использует gradle), нам не нужно иметь заранее установленный Gradle на своем ПК. Эта оболочка может сама скачать и установить нужную версию, разобрать аргументы и выполнить задачи. По сути, используя gradlew, мы можем распространять/делиться проектом со всеми, чтобы использовать одну и ту же версию и функциональность Gradle. Gradlew читает информацию из файла gradle/wrapper/gradle-wrapper.properties.
Мы собрали наше приложение, но пока оно только запускается, но не выполняет никаких других функций. Заходим в файл build.gradle, можно сказать, что это мозг нашего проекта. Здесь хранится вся основная информация для конфигурации и сборки проекта. Сейчас он выглядит так:
Добавим в dependencies следующую зависимости для работы с PEST API:
@RestController = @Controller + @ResponseBody. Аннотация @Controller умеет слушать, получать и отвечать на запросы. А @ResponseBody дает фреймворку понять, что объект, который вы вернули из метода надо прогнать через HttpMessageConverter, чтобы получить готовое к отправке клиенту представление.
В файл application.properties добавим строку:
Вуаля! Теперь наше приложение не только запускается, но и выводит сообщение «spring_boot_example» по адресу: http://localhost:8080/.
2. Напишем приложение с сущностями, создадим контроллеры и подключим JPA
Теперь расширим возможности нашего проекта. Для этого добавим JPA, пару сущностей и напишем для них контроллеры.
2.1. Создадим сущности и репозиторий
Аннотируем классы следующим образом:
Поле Address в классе User выглядит следующим образом:
Осталось сгенерировать методы hashCode, equals и toString. Для User мы генерируем hashCode и equals только по полю login, этого достаточно, так как мы сделали это поле уникальным и отличным от null. Так же для User при переопределении toString мы не используем поле address. Ранее упоминалось, что инициализация ленивая, и значение для этого поля не подтягивается сразу, а если мы попробуем обратиться к hibernate и попросить достать сущность без @Transactional, то упадем с ошибкой.
Полный код сущностей:
Добавим к приложению репозиторий – класс, который умеет работать с базой данных. Реализация очень проста, просто создадим свой интерфейс и унаследуем его от JpaRepository. Все. SpringBoot сам сгенерирует класс, имплементрирующий этот интерфейс и подставит там, где это необходимо.
JpaRepository – это интерфейс фреймворка Spring Data предоставляющий набор стандартных методов JPA для работы с БД.
2.2. Добавим контроллеры.
Аннотация @Data добавляет get, set, toString, equals, hashCode, конструктор по всем полям, т.е. практически полностью генерирует POJO класс.
Теперь можно создать наш полноценный контроллер. Помечаем класс аннотациями @RestController и @RequestMapping(«/api/v1/users»).
У нашего приложения будет 5 контроллеров. Два на получение данных: всех пользователей и по id, на создание, изменение и удаление данных о пользователе.
Получаем список пользователей:
На аннотацию @GetMapping мы уже смотрели ранее. Свойство produces = APPLICATION_JSON_VALUE говорит о том, что данные возвращаются в формате json. В данном методе мы возвращаем лист с данными UserResponse.
Получаем пользователя по id:
Этот метод аналогичен предыдущему, за исключением того, что мы также получаем id пользователя. Аннотация @PathVariable говорит о том что информация извлекается из адреса и передается в переменную указанную в <>.
Обновляем пользователя по id:
Удаляем пользователя по id:
2.3. Напишем сервисную часть приложения.
Теперь посмотрим на логику сервиса. Для начала создадим интерфейс с пятью методами, а затем унаследуемся от него. Наш интерфейс выглядит так:
Создадим новый класс имплементирующий созданный выше интерфейс:
Теперь добавим логику в каждый метод.
Получаем список пользователей:
Хочу обратить внимание, что раньше мы говорили, что если мы обращаемся к сущности address вне @Transactional метода, то упадем с ошибкой. Так вот, тут такое не произойдет, т.к. метод как раз имеет эту аннотацию, hibernate ее видит и поднимает это поле из БД.
Получаем пользователя по id:
По аналогии с buildUserResponse создадим дополнительный метод buildUserRequest.
Это не самый лучший подход, так как для каждой сущности должны быть свои контроллеры и репозитории. Но в контексте нашего приложения Address и User не могут существовать отдельно, поэтому мы можем воспользоваться этим приемом.
Обновляем пользователя по id:
В этом методе мы находим пользователя, по аналогии с методом findById, если такой объект нашелся, то сетим ему поля в методе userUpdate.
Удаляем пользователя по id:
Теперь добавим свой обработчик ошибок. Spring умеет перехватывать ошибки и возвращать вместо них то, что мы захотим. Для этого создадим объект ExceptionResponse, который будет возвращать только сообщение из ошибки.
3. Запустим и протестируем наше приложение, удивимся что все работает и порадуемся, что провели время с пользой и узнали что-то новое.
Добавим креды для подключения к БД в application.properties:
Теперь поднимем базу (для этого я использую докер) и добавляем таблички в БД.
Ура! Наше приложение написано и полностью работает, теперь его можно тестировать.
Подведем итог. Мы написали простое приложение и затронули несколько важных тем. Разработали контроллеры для разных REST методов, написали сервисную частью, включая свой обработчик ошибок. Подключили JPA и воспользовались методами интерфейса JpaRepository.
Spring Boot простое приложение
Сегодня поговорим о самом популярном java фреймворке — Spring. Он очень полезен при разработке практически любых продуктов:
Мы уже разрабатывали веб приложение только средствами Java и убедились, что местам это довольно трудоемкая работа. Особенно, что касается работы с большой базой данных.
Сегодня я покажу как создать простое веб приложение с использованием Spring Boot. Перед тем, как начать, предлагаю немного ознакомиться с особенностями Spring Boot.
На официальном сайте сказано, что Spring Boot предназначен для быстрого и простого запуска приложений с минимумом настроек с Вашей стороны. И это правда. Для запуска большинства приложений от Вас не потребуется много настроек, конфигураций. Более того, для запуска веб приложения на Spring Boot больше не нужно качать и устанавливать сервер приложений типа Tomcat. Данный фреймворк идет со встроенным томкатом. Больше не нужно создавать web.xml да и вообще иметь дело с каким либо xml файлом. Разве что с pom.xml. Да и при желании можно заменить Maven сборку на Gradle.
Теперь, когда мы мы рассмотрели все «плюшки» Spring Boot, можно начать программировать.
Для начала нужно создать простое мавен приложение. Я сторонник Maven сборки. Вы можете выбрать любой сборщик приложений.
Далее, как и всегда, нужно добавить необходимые зависимости в pom.xml.
Для Spring Boot будет достаточно spring-boot-starter и spring-boot-starter-web.
xmlns = «http://maven.apache.org/POM/4.0.0» xmlns:xsi = «http://www.w3.org/2001/XMLSchema-instance»
xsi:schemaLocation = «http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd» >
> 4.0.0 >
> com.javamaster >
> sprboot >
> 0.0.1-SNAPSHOT >
Для большинства проектов, изменять значения по умолчанию попросту не нужно. Ведь здесь используются стандартный и принятые правила размещения файлов и классов.
Так как теперь у нас нет сервлета или web.xml, то точкой входа в нашу программу будет обычный метод main, который нам так знаком. Для конфигурации нужно добавить лишь несколько строк кода и приложение уже можно запускать.
Нужно создать класс с настройками и добавить в него main для запуска:
import org.springframework.boot.SpringApplication ;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration ;
import org.springframework.boot.autoconfigure.SpringBootApplication ;
@SpringBootApplication //аннотация которая обозначает, что это spring boot приложение
//а значит, что программа должна быть запущена как spring boot
@EnableAutoConfiguration //включает автоконфигурацю и тем самым избавляет нас от написания
//дополнительных классов конфигураций
//по желанию можно написать свою конфигурацию. приложение выберет именно Вашу кастомноую конфигурацию
public class Application <
public static void main ( String [ ] args ) <
SpringApplication. run ( Application. class ) ; //запуск приложения
Как видите, кода очень даже немного. Это все, о чем нам нужно было беспокоиться. Теперь можно приступать к написанию своего приложения не думаю о настройках.
За потребностью, можно написать свои настройки с аннотацией @Configuration. Приложение автоматически выберет Ваши настройки и проигнорирует заданные ему по умолчанию. Так например, можно дописать настройки безопасности или Hibernate.
Теперь, когда конфиги готовы, осталось только написать контроллер и создать простую страничку. Как я уже говорил выше, по умолчанию spring boot будет искать наши странички в src/main/resources/static. Давайте туда и поместим наш index.html:
Теперь создадим простой контроллер:
import org.springframework.stereotype.Controller ;
import org.springframework.web.bind.annotation.GetMapping ;
@Controller
public class HomeController <
@GetMapping ( «/» )
public String getIndex ( ) <
return «index» ;
>
>
Вот и все. Очень просто и быстро с минимумом настроек, как и говорили авторы Spring Boot.
Вот как выглядит моя структура файлов в Eclipse:
Теперь запустите класс Application как обычное java приложение и следите за консолью. Должно быть примерно как на картинке ниже:
Видим сообщение о том, что Tomcat успешно запустился и слушает по порту 8080. Если Вы не меняли стандартный порт, то приложение запуститься именно на этом порту.
Теперь переходим в браузер, набираем http://localhost:8080/ и видим результаты нашей работы:
Вот и все. У Вас готовое Spring boot приложение.
Теперь, как я и обещал, я покажу небольшую кастомизацию spring boot. Допустим, Вы решили пользоваться не html страничками, a jsp или поменять расположение Ваших файлов. Для этого нужно указать префикс и суффикс, как мы это делали в простом Spring MVC приложении. Spring Boot ищет настройки в файле application.properties который нужно расположить в том же src/main/resources/:
Изменять в настройках и контроллере ничего не нужно. В application.properties можно добавлять любые настройки Вашего приложения: соединение с базой данных, настройки сервера, пути к файлам и т. д.
Я записал небольшое видео, где показано, как настроить Spring Boot для jsp. В описании к видео ссылка на код.
Для тех, кто хочет получить практический опыт работы с java приложениями, открыт набор Java mentor. Программа подразумевает создание веб приложения на основе Spring Boot.
Spring Boot: быстрое знакомство и старт на примере простого веб-приложения
Авторизуйтесь
Spring Boot: быстрое знакомство и старт на примере простого веб-приложения
Senior Software Developer
На этом примере рассмотрим, как можно быстро научиться создавать веб-приложения, которые могут из микроприложений вырасти в серьезные проекты.
Первоначальная настройка приложения
Переходим на сайт Spring Initializr и подготавливаем минимальный шаблон для нашего будущего приложения:
Создание каркаса проекта
В левой части оставляем настройки по умолчанию, кроме версии Java (будет достаточно 8), и заполняем Project Metadata.
В правой части необходимо добавить зависимости, нужные для приложения.
Всё готово, нажимаем GENERATE и получаем архив с исходным кодом проекта. Это минимальный каркас, который импортируем в используемую IDE.
В этом проекте используется IntelliJ IDEA.
В следующих диалоговых окнах все настройки оставляем по умолчанию. Единственное, в одном из окон удостоверимся, что имеем ранее установленную JDK соответствующей версии, в данном случае 8.
Если JDK не была установлена ранее, её можно скачать с официального сайта.
Все остальные окна кликаем Next и в последнем — Finish.
Кратко рассмотрим структуру проекта. В первую очередь интересны:
Создадим дополнительные пакеты :
Основной сущностью данного приложения будет сущность Task, которая будет иметь идентификатор, описание задачи, дату выполнения, приоритет выполнения.
Создадим класс Task в пакете entity
Класс помечен аннотацией @Entity. Она указывает на то, что данный класс является сущностью и будет сохраняться в БД.
Данная сущность имеет первичный ключ поле id. Поле помечено аннотацией @Id и аннотацией @GeneratedValue, которая задает стратегию генерации первичного ключа как автоматическую генерацию, в этой сущности – целые числа в порядке возрастания.
Создадим интерфейс TaskRepository в пакете repository
Класс унаследован от JpaRepository – интерфейса фреймворка Spring Data, предоставляющего набор стандартных методов JPA для работы с БД. Для данного приложения нет необходимости создавать дополнительные методы.
Создадим класс TaskService в пакете service
Класс содержит три метода для работы с задачами:
Создадим контроллер TaskController в пакете controller
Класс контроллер содержит три метода для управления задачами. При вызове методы обращаются в сервис TaskService, производят необходимые действия с сущностью и перенаправляют по заданному пути.
Замечание. Более правильно было бы добавить еще один интерфейс TaskService, который будет реализовывать существующий класс TaskService (изменим название на TaskServiceImpl), но в рамках этого приложения делать это не будем.
Создадим index.ftlh – шаблон для Freemarker в каталоге resources/templates
Добавим простой CSS-файл style.css в каталоге resources/static/css:
Структура проекта:
Проект готов к запуску и работе
Запускаем первое приложение на Spring Boot
Переходим к классу OrganizerApplication.class. Он был сформирован автоматически на первом шаге конфигурации каркаса проекта. Его содержимое:
Переходим в меню >Run-> Run ‘OrganizerApplication’ или запускаем через сочетание клавиш Shift+F10. Процесс запуска отобразится в консоли ниже.
Переходим в браузер, набираем в адресной строке адрес localhost:8080 и наблюдаем работающий прототип приложения Organizer.
Органайзер на Spring Boot
Так с помощью Spring Boot с минимальным набором классов менее чем за час можно создать работающее веб-приложение или основу для будущих проектов. Это уже тема другой статьи.
Посмотрите также 10 шпаргалок для веб-разработчика. Там есть видеокурс по Spring Boot.
Введение в Spring Boot: создание простого REST API на Java
Из-за громоздкой конфигурации зависимостей настройка Spring для корпоративных приложений превратилась в весьма утомительное и подверженное ошибкам занятие. Особенно это относится к приложениям, которые используют также несколько сторонних библиотек
Каждый раз, создавая очередное корпоративное Java-приложение на основе Spring, вам необходимо повторять одни и те же рутинные шаги по его настройке:
1. Представляем Spring Boot
Авторы Spring решили предоставить разработчикам некоторые утилиты, которые автоматизируют процедуру настройки и ускоряют процесс создания и развертывания Spring-приложений, под общим названием Spring Boot
Spring Boot — это полезный проект, целью которого является упрощение создания приложений на основе Spring. Он позволяет наиболее простым способом создать web-приложение, требуя от разработчиков минимум усилий по его настройке и написанию кода
2. Особенности Spring Boot
Spring Boot обладает большим функционалом, но его наиболее значимыми особенностями являются: управление зависимостями, автоматическая конфигурация и встроенные контейнеры сервлетов
2.1. Простота управления зависимостями
Чтобы ускорить процесс управления зависимостями, Spring Boot неявно упаковывает необходимые сторонние зависимости для каждого типа приложения на основе Spring и предоставляет их разработчику посредством так называемых starter-пакетов (spring-boot-starter-web, spring-boot-starter-data-jpa и т.д.)
Starter-пакеты представляют собой набор удобных дескрипторов зависимостей, которые можно включить в свое приложение. Это позволит получить универсальное решение для всех, связанных со Spring технологий, избавляя программиста от лишнего поиска примеров кода и загрузки из них требуемых дескрипторов зависимостей (пример таких дескрипторов и стартовых пакетов будет показан ниже)
Например, если вы хотите начать использовать Spring Data JPA для доступа к базе данных, просто включите в свой проект зависимость spring-boot-starter-data-jpa и все будет готово (вам не придется искать совместимые драйверы баз данных и библиотеки Hibernate)
Если вы хотите создать Spring web-приложение, просто добавьте зависимость spring-boot-starter-web, которая подтянет в проект все библиотеки, необходимые для разработки Spring MVC-приложений, таких как spring-webmvc, jackson-json, validation-api и Tomcat
Другими словами, Spring Boot собирает все общие зависимости и определяет их в одном месте, что позволяет разработчикам просто использовать их, вместо того, чтобы изобретать колесо каждый раз, когда они создают новое приложение
Следовательно, при использовании Spring Boot, файл pom.xml содержит намного меньше строк, чем при использовании его в Spring-приложениях
Обратитесь к документации, чтобы ознакомиться со всеми Spring Boot starter-пакетами
2.2. Автоматическая конфигурация
Второй превосходной возможностью Spring Boot является автоматическая конфигурация приложения
После выбора подходящего starter-пакета, Spring Boot попытается автоматически настроить Spring-приложение на основе добавленных вами jar-зависимостей
Например, если вы добавите Spring-boot-starter-web, Spring Boot автоматически сконфигурирует такие зарегистрированные бины, как DispatcherServlet, ResourceHandlers, MessageSource
Если вы используете spring-boot-starter-jdbc, Spring Boot автоматически регистрирует бины DataSource, EntityManagerFactory, TransactionManager и считывает информацию для подключения к базе данных из файла application.properties
Если вы не собираетесь использовать базу данных, и не предоставляете никаких подробных сведений о подключении в ручном режиме, Spring Boot автоматически настроит базу в памяти, без какой-либо дополнительной конфигурации с вашей стороны (при наличии H2 или HSQL библиотек)
Автоматическая конфигурация может быть полностью переопределена в любой момент с помощью пользовательских настроек
2.3. Встроенная поддержка сервера приложений — контейнера сервлетов
Каждое Spring Boot web-приложение включает встроенный web-сервер. Посмотрите на список контейнеров сервлетов, которые поддерживаются «из коробки»
Разработчикам теперь не надо беспокоиться о настройке контейнера сервлетов и развертывании приложения на нем. Теперь приложение может запускаться само, как исполняемый jar-файл с использованием встроенного сервера
Если вам нужно использовать отдельный HTTP-сервер, для этого достаточно исключить зависимости по умолчанию. Spring Boot предоставляет отдельные starter-пакеты для разных HTTP-серверов
Создание автономных web-приложений со встроенными серверами не только удобно для разработки, но и является допустимым решением для приложений корпоративного уровня и становится все более полезно в мире микросервисов. Возможность быстро упаковать весь сервис (например, аутентификацию пользователя) в автономном и полностью развертываемом артефакте, который также предоставляет API — делает установку и развертывание приложения значительно проще
3. Требования к установке Spring Boot
Для настройки и запуска Spring Boot приложений требуется следующее:
4. Создание Spring Boot приложения
Теперь давайте перейдем к практике и реализуем очень простой REST API для приема платежей, используя возможности Spring Boot
4.1. Создание web-проекта с использованием Maven
Создайте Maven-проект в используемой вами IDE, назвав его SpringBootRestService
Обязательно используйте версию Java 8+, поскольку Spring Boot не работает с более ранними версиями
4.2. Конфигурация pom.xml
Вторым шагом необходимо настроить Spring Boot в файле pom.xml
Все приложения Spring Boot конфигурируются от spring-boot-starter-parent, поэтому перед дальнейшим определением зависимостей, добавьте starter-parent следующим образом:
Т.к. мы создаем REST API, то необходимо в качестве зависимости использовать spring-boot-starter-web, которая неявно определяет все остальные зависимости, такие как spring-core, spring-web, spring-webmvc, servlet api, и библиотеку jackson-databind, поэтому просто добавьте в pom.xml следующее:
Теперь следующие jar-библиотеки автоматически импортируются в ваш проект:
Следующий шаг — добавляем Spring Boot плагин:
Последний шаг — сделать так, чтобы Maven генерировал исполняемый jar-файл при сборке:
Ниже приведен полный файл pom.xml:
Как видите, используя одну зависимость, мы можем создать полностью функциональное web-приложение
4.3. Создание ресурсов REST
Теперь мы собираемся создать контроллер платежей вместе с POJO-классами для запросов и ответов
Напишем класс запроса платежа:
А также класс, обрабатывающий базовый ответ, возвращаемый нашим сервисом:
А теперь создадим контроллер:
4.4. Создание основного класса приложения
Этот последний шаг заключается в создании класса конфигурации и запуска приложения. Spring Boot поддерживает новую аннотацию @SpringBootApplication, которая эквивалентна использованию @Configuration, @EnableAutoConfiguration и @ComponentScan с их атрибутами по умолчанию
Таким образом, вам просто нужно создать класс, аннотированный с помощью @SpringBootApplication, а Spring Boot включит автоматическую настройку и отсканирует ваши ресурсы в текущем пакете:
5. Развертывание приложения Spring Boot
Теперь давайте воспользуемся третьей замечательной особенностью Spring Boot — это встроенный сервер. Все, что нам нужно сделать — это создать исполняемый jar-файл с помощью Maven и запустить его, как обычное автономное приложение:
Наш REST API запущен и готов обслуживать запросы через порт 8080 (по умолчанию)
В этой статье мы рассмотрели возможности Spring Boot и создали полностью рабочий пример с использованием встроенного сервера
В переводе обновили информацию:
UPDATE:
Как заметил Lure_of_Chaos, теперь уже все можно сделать автоматически через SPRING INITIALIZR. Причем не выходя из любимой JetBrains IntelliJ IDEA.