для чего нужен spring boot
Стоит ли использовать Spring Boot в вашем следующем проекте?
Большинство моих профессиональных Java проектов за последнее десятилетие были основаны на Spring или JEE. Обе платформы развиваются достаточно уверенно, однако все ещё страдают от различных проблем.
Spring и JEE по-прежнему остаются золотыми стандартами для масштабных Java-проектов и больших команд разработчиков, трудящихся над сложными enterprise-решениями. Однако, неизбежным следствием зрелости Java-сообщества стала частичная потеря прежнего энтузиазма и инновационности, что существенно ударило по авторитету обоих.
JEE изменилась довольно резко на протяжении многих лет, но до сих пор осуждается разработчиками за подходы и решения, которые были обозначены создателями платформы как deprecated ещё начиная с версии EJB 2.x. Многие люди до сих пор называют JEE как “J2EE”, хотя изменение названия состоялось 8 лет назад!
Spring тоже заметно усовершенствовался, однако далеко не всеми пользователями это воспринимается. Невзирая на возможность создания при помощи Spring 3.x и выше современных приложений с прозрачной, неоторванной от кода конфигурацией, большинство проектов продолжают с избытком пестреть XML-файлами и устаревшими архитектурными решениями. Проблема в том, что много разработчиков по тем или иным причинам не меняют отработанного на предыдущих версиях подхода.
По указанным причинам открылась дорога другим языкам и фреймворкам. Java был, вероятно, самым популярным языком для личных проектов, более десятка лет тому назад, но молодые разработчики сегодня, кажется, стали обращать больше внимания на Python, Scala и т.д. Наиболее влиятельные веб-фреймворки предыдущего десятилетия Rails, и основанная на Ruby Sinatra породили ряд микро-фреймворков на протяжении последних пяти лет.
Groovy и Grails, в мире Java, стали первым серьёзным ответом Ruby и Rails. Их теперь можно встретить в наборе инструментов даже самых консервативных команд enterprise-разработки. Однако, новые фреймворки на основе JVM идут гораздо дальше. Вместо просто обёртывания API JEE и Spring в легкую для использования интерфейс-оболочку Play фреймворк начал, так сказать с чистого листа, отбрасывая даже, казалось бы фундаментальную модель Java-сервлета.
Spring уже не рассматривается как современный инновационный инструмент. Разработчики еще используют его, особенно для старых приложений, но в основном, потому что они должны, а не потому, что они этого сами хотят. Я не могу вспомнить, когда последний раз я говорил с разработчиком, использовавшем Spring в личном проекте, в то время как Play или совершенно другая платформа встречаются повсеместно.
Это позор, ведь Spring – невероятно мощный инструмент, если получится правильно его настроить. Spring Data JPA предоставляет простое управление реляционными базами данных без написания классов DAO, также Spring Data JPA позволяет получить тот же функционал по отношению к NoSQL хранилищам данных, если получится правильно его настроить. Кроме того, с помощью Spring вы имеете возможность осуществлять enterprise-интеграцию, доступ к API самых популярных социальных сервисов для ваших веб- или android-приложений, позаботится о безопасности вашего приложения посредством Spring Security, но, опять же, если у вас получится правильно все сконфигурировать.
Построение приложения на основе Spring может быть очень болезненным процессом. Отчасти это из-за большого количества существующих альтернатив при выборе технологий. Например, стоит ли осваивать и использовать Spring Data JPA, если вы уже потратили время на изучение JdbcTemplate и Hibernate/JPA? Какая разница между Spring Data REST и Spring HATEOAS?
Другим осложняющим фактором является то, что Spring редко признает что-либо deprecated, и не предоставляет достаточной информации для принятия обоснованного решения по выбору технологий, устранения разнообразных конфликтов и решения других часто возникающих проблем. Если вы будете искать в Интернете пример устранения какой-то неполадки, ссылки на устаревшие подходы и решения будут в топе результатов поиска. По большей части именно из-за этого XML-конфигурация остается такой распространённой, невзирая на простоту имплементации и поддержки конфигурации на основе аннотаций. Вместо использования чистой системы шаблонов такой как Thymeleaf или Velocity, в большинстве приложений по-прежнему применяется JSP с JSTL.
Жажда к ликвидации указанных проблем никогда не угасала у создателей Spring. Вдохновившись инструментом командной строки Rails, они презентовали Spring Roo – систему быстрой разработки, которая кроме того позволяет создавать элементы, такие как веб-контроллеры или JPA сущности посредством командной строки. Тем не менее, для нетривиального использования, освоить Spring Roo почти так же сложно, как собирать приложения вручную. Многих разработчиков отталкивало обилие аннотаций и AspectJ-файлов, которые Roo повсеместно добавляет в проект для обеспечения своей “магии”. Хотя и заявляется, что Roo можно легко и безболезненно удалить из проекта, если понадобится, реальность оказывается более суровой, чем теория. И даже если у вас все получилось, конвертация AspectJ в Java напрочь лишает вас возможности пользоваться магическим инструментом командной строки.
Spring Boot – следующая генерация средств упрощения процесса конфигурации Spring приложений. Он не является средством автоматической генерации кода, а представляет собой плагин для системы автоматизации сборки проектов (поддерживает Maven и Gradle).
Плагин предоставляет возможности для тестирования и разворачивания Spring приложения. Команда mvn spring-boot:run обеспечивает запуск вашего приложения на порту 8080. Это чем-то напоминает довольно популярный плагин Maven Jetty. Кроме того, Spring Boot позволяет упаковывать приложение в отдельный jar-файл, с внедренным полноценным контейнером Tomcat. Этот подход позаимствован у модели развертывания приложений фреймворка Play (вместе с тем вы также можете создавать традиционные war-файлы).
Основная выгода Spring Boot – конфигурирование ресурсов исходя из содержания classpath. Например, если pom.xml файл вашего Maven проекта содержит JPA зависимости и драйвер PostgreSQL, Spring Boot настроит persistence-модуль для PostgreSQL. Если вы добавили веб-зависимость, вы получите сконфигурированный по умолчанию Spring MVC. Если вам нужна персистентность и ничего кроме этого, Spring Boot сконфигурирует Hibernate как JPA провайдер с базой данных HSQLDB. Если вы создаете веб-приложение, но не указываете ничего дополнительно, Spring Boot сконфигурирует view resolver для системы шаблонов Thymeleaf.
Говоря о конфигурации по умолчанию, Spring Boot достаточно интуитивен в этом плане. Вы можете не всегда быть согласны с его выбором настроек, но, по крайней мере, он предоставит вам работающий модуль. Это очень полезный подход, особенно для начинающих разработчиков, которые могут начать работу с настройками по умолчанию, а потом, по мере изучения существующих альтернатив, вносить изменения в конфигурацию. Согласитесь, это намного лучше чем получить кучу сложных вопросов, без решения которых просто невозможно стартовать. Вдобавок на официальной странице проекта есть ряд полноценных туториалов, позволяющих быстро понять и практически реализовать все основные виды проектов на уровне “Hello world”.
Построение инфраструктуры приложения, фактически заключается в добавлении нужных модулей в pom.xml:
а также написании main Java-класс следующим образом:
Для большинства случаев изменения настроек по умолчанию, достаточно изменить POM-файл. Так, в примере выше продемонстрированно добавление зависимости для базы данных H2. Spring Boot, видя такое изменение, конфигурирует persistence-модуль JPA для базы данных Н2 вместо, предлагаемой по умолчанию HSQLDB. Если вам хочется использовать Jetty как встроенный контейнер, вместо предлагаемого по умолчанию Tomcat, просто добавьте соответствующую зависимость.
В данный момент Spring Boot находится на этапе становления, и, безусловно, до выхода на стабильный уровень ему предстоит пережить немало метаморфоз. Возможно, его еще рано использовать для построения серьезных систем, однако он вполне подходит для выполнения разного рода персональных, тренировочных и тестовых проектов, при реализации которых очень важно избавится от нежелательного объема непродуктивной, рутинной работы, никоим образом не связанной с созданием полезной функциональности.
В контексте потенциальных перспектив перерастания Spring Boot в будущем в серьезный инструмент для Spring разработки, особенно обнадёживает присутствие приемлемой технической документации (правда, только на английском языке и все ещё достаточно скудной, в сравнении с 800 страничной “энциклопедией” Spring Framework).
Spring Boot vs Spring MVC vs Spring — Как они сравниваются?
Spring Boot vs Spring MVC vs Spring — Как они сравниваются?
Spring, Spring Boot, Spring MVC, везде есть слово “spring”! Давайте пройдемся где и когда вы можете применять каждый из этих инструментов
В этой статье, вы увидите обзоры: Spring, Spring MVC, и Spring Boot, узнаете какие проблемы они решают, и где они лучше всего применимы. Самый важный в факт что вы узнаете, является тем что Spring, Spring MVC, и Spring Boot не конкурируют за одно и то же место. Они решают разные проблемы, и они решают их очень хорошо.
Что за основная проблема, которую этот Spring Framework решает?
Долго и упорно подумайте. Какова проблема, решаемая Spring Framework?
Почему это важно? Потому что, когда DI или IOC правильно используются, мы можем разрабатывать слабо связанные приложения. А слабо связанные приложения могут быть легко протестированы юнит-тестами.
Давайте рассмотрим простой пример.
Пример без внедрения зависимостей
Рассмотрим пример ниже: WelcomeController зависит от WelcomeService, чтобы получить приветственное сообщение. Что он делает, чтобы получить экземпляр WelcomeService?
Эта строка создает экземпляр данного сервиса. А это значит что они сильно связаны. Например, если я создаю мок для WelcomeService в юнит-тесте для WelcomeController, как мне заставить WelcomeController использовать мок? Не легко!
Простой пример с внедрением зависимостей
Мир выглядит намного проще с внедрением зависимостей. Вы позволяете Spring Framework делать тяжелую работу. Мы просто используем две простые аннотации: Component и Autowired.
В юнит-тесте, я могу попросить Spring framework подключить мок для WelcomeService к WelcomeController. (Spring Boot делает вещи проще делая это с аннотацией @MockBean. Но это уже совсем другая история!)
Что еще решает Spring Framework?
Проблема 1: Дублирование/Загрязнение кода
Останавливается ли Spring Framework с внедрением зависимостей? Нет. Он строится на основной концепции внедрения зависимостей с несколькими модулями Spring
Приносят ли эти модули новую функциональность? Нет. Мы можем делать все это на J2EE или Java EE. Так, что они приносят? Они приносят простые абстракции. Целью этих абстракций является:
Проблема 2: хорошее интегрирование с другими фреймворками
Отличная вещь насчет Spring Framework, это то, что он не пытается решать проблемы которые уже решены. Все что он делает, это предоставляет отличную интеграцию с другими фреймворками, которые в свою очередь предоставляют отличные решения.
Почему нам нужен Spring Boot?
У приложений, основанных на Spring, много конфигураций.
Когда мы используем Spring MVC, нам необходимо сконфигурировать: component scan, dispatcher servlet, view resolver, web jars(для доставки статического контента) среди других вещей.
Код ниже показывает типичную конфигурацию dispatcher servlet в web приложении.
Когда мы используем Hibernate/JPA, нам надо сконфигурировать источник данных, фабрику менеджера сущностей, менеджер транзакций, и другие штуки.
Проблема 1: Spring Boot авто конфигурация: Можем ли мы думать иначе?
Spring Boot приносит новый мыслительный процесс вокруг всего этого.
Проблема 2: Spring Boot Starter Projects: Построен вокруг хорошо известных паттернов
Давайте скажем что хотим разработать веб приложение.
Прежде всего нам потребуется определить фреймворки, которые хотим использовать, какие версии использовать и как их вместе подсоединить.
У всех веб приложений аналогичные потребности. Ниже перечислены зависимости которые используются в Spring MVC. Они включают в себя Spring MVC, Jackson Databind, Hibernate-Validator и Log4j.
Если вы хотите разрабатывать веб приложение или приложение для RESTful сервисов, ваш выбор — Spring Boot Start Web. Давайте быстро создадим проект с Spring Boot Starter Web используя Spring Initializr.
Зависимости для Spring Boot Starter Web
Следующий скриншот показывает разные зависимости, которые были добавлены в наше приложение.
Зависимости могут быть классифицированы на:
Параметры проекта Spring Boot Starter
Как мы видим из Spring Boot Starter Web, стартовые проекты помогают нам быстро начать разработку определенных типов приложений.
Другие цели Spring Boot
Также есть несколько стартеров для технических вещей:
Spring Boot: от начала до продакшена
В данной статье я попробую расписать все шаги, которые потребуются для создания небольшого проекта на Spring Boot и развертывания его на боевом сервере.
Не будем тянуть долгими прелюдиями о философии java и spring’а, и сразу приступим к делу.
Для начала нам необходимо создать каркас приложения, внедрив туда весь необходимый зоопарк технологий(как минимум Spring, JPA, JDBC). До появления spring boot нужно было потратить на это немало времени, если конечно у вас не было рабочей заготовки в закромах кода. И именно сложность создания подобного каркаса, как мне кажется, останавливает многих от разработки небольших веб-проектов на java. Конечно, когда-то был хромой spring roo, который мог создать подобный каркас в ущерб производительности(привет аспектам), но даже с ним количество и сложность конфигурационных файлов заставляли долго медитировать над ними неподготовленного разработчика. Однако теперь с приходом Boot и Spring 4 жизнь стала немного проще и количество конфигурационных файлов заметно уменьшилось.
Если же у вас нет данной IDE, то скачиваем Spring Boot CLI, следуем инструкции в INSTALL.txt. Нужно задать системную переменную SPRING_HOME(путь к папке со Spring Boot, не к папке bin!) и добавить путь к SPRING_HOME/bin в системную переменную PATH на windows.
Итак, консоль спринга настроили, теперь самое время создать проект. Сделать это можно следующей командой:
UPDATE
Кроме того, как написали в комментариях, существует еще веб-конструктор: start.spring.io
Далее импортируем получившийся каркас в любимую IDE и начинаем его модифицировать под наши нужды.
Для начала добавим в каталог src/main папку webapps. Все веб-ресурсы мы будем создавать в ней, а не в папке resources, как хочет того спринг. Дело в том, что если мы будем создавать файлы в папке resources, то тогда мы лишимся возможности видеть изменения, сделанные в наших веб-ресурсах, без перезагрузки сервера. А это может быть неприятно, когда ради того, чтобы посмотреть изменившийся текст на веб-странице приходится перезапускать веб-сервер.
Теперь в папке webapps создаем файл index.html и папки css, js, font, images, в которые будем класть соответствующие ресурсы.
Для примера сделаем самый простой каркас index.html:
Изменим файл pom.xml
Должно получиться что-то подобное:
Из pom-файла мы можем увидеть следующее:
Мы используем java 8(самое время ее попробовать). Наш класс приложения называется com.yourcompany.Application(не забудьте переименовать стандартно сгенерированный класс, который может называться к примеру DemoApplication).
Мы используем postgresql 9.4(тоже неплохо бы установить его локально на свою машину). Connection pool для взаимодействия с базой данных мы берем самый модный и производительный (HikariCP). Кроме того, мы используем специальный плагин, который, когда мы будем генерировать итоговый jar’ник, перенесет все наши данные из webapp в resources/static, как того хочет spring boot. В противном случае вы не сможете увидеть все те веб-страницы, что создадите в папке webapps, когда запустите jar-ник.
Добавим пакет config и создадим в нем класс JpaConfig:
Кроме того, добавим в файл application.properties следующие строчки:
И наконец в Application.java меняем строку инициализации на следующую:
Тем самым мы настроили подключение к СУБД PostgreSQL.
Не забываем создать саму базу данных и простенькую таблицу в ней. Сделать это удобнее всего через PgAdmin.
Создав в ней пустую базу yourapp_data, выполняем скрипт создания таблицы:
Теперь настало время немного заняться начинкой нашего проекта. А именно добавить какую-нибудь сущность БД и научиться с ней работать, получая с клиента данные для ее формирования и отправляя клиенту же данные об уже созданных сущностях.
Создаем пакеты controller, entity, repository, service, utils.
В пакете entity создаем интерфейс:
Аннотации JPA и Hibernate в данном примере использовать не будем, так как эти технологии сильно замедляют работу(запрос может выполняться в 10 раз медленнее, чем на чистом jdbc), а так как у нас нет сильно сложных сущностей, для которых реально может потребоваться ORM, то воспользуемся обычным jdbcTemplate.
Создаем интерфейс репозитория:
Вместо уже упомянутого jdbcTemplate, мы, как видите, используем JdbcOperations, который является его интерфейсом. Нам приходится использовать везде интерфейсы, отделяя их от реализации, так как, во-первых это стильно, модно, молодежно, а во-вторых, spring в нашем случае использует стандартный jdk’шный Proxy для наших объектов, поэтому напрямую инжектить реализацию не получиться, пока мы не введем полноценные аспекты и AspectJ compile-time weaving. В нашем случае этого и не требуется, чтобы не перегружать приложение.
Осталось уже немного. Создаем наш сервис(мы же хорошие разработчики и должны отделить бизнес-логику от логики работы с СУБД?).
Отлично. Теперь создаем пару вспомогательных классов, необходимых для реализации контроллера:
Это наша реализация Exception’а. Может пригодиться в будущем, хотя и не обязательна, но на нее завязан следующий класс:
Если мы словили такую ошибку в нашем контроллере, то она будет обработана дополнительно в этом методе.
Наконец напишем небольшой классик, который будет формировать структуру данных для передачи на клиент:
Все, со вспомогательными классами закончили. Осталось написать наш контроллер. Он будет простым, как пробка:
В нем два метода — сохранить полученные данные и выдать порцию случайных данных на клиент. Контроллер унаследован от созданного нами ранее ExceptionHandlerController. Обработка исключений написана только как шаблон и нуждается в соответствующей доработки под себя.
Итак, основная часть серверного кода написана, осталось проверить его работу на клиенте. Для этого нужно доработать наш файл index.html и заодно добавить библиотеку jquery в каталог js.
index.html:
Да, UI получился не бог весть каким красивым, но зато с его помощью мы можем проверить работу приложения.
Запустим наш проект. В Intellij Idea это можно сделать через специальную конфигурацию запуска(Spring Boot).
Если все сделано верно, то по адресу localhost:8080 вы сможете увидеть заголовок Hello World, строку ввода и две кнопки. Попробуйте ввести что-нибудь в строку ввода и нажать на кнопку POST. Если после этого вы увидите аналогичный текст ниже поля ввода, то все работает как надо. Теперь останется модифицировать проект под свои нужды, добавить модный UI(например materializecss.com) и творить разумное, доброе, вечное.
Однако рано или поздно вы сотворите желаемое и встанет вопрос о том, как донести ваше детище в массы. Об этом будет вторая часть статьи.
Начнем с малого, но важного.
Даже если проект небольшой, все равно для него потребуется свой домен. Если вы просто обкатываете какую-нибудь идею и не хотите тратить бешеные деньги для регистрации домена на том же godaddy, то можете воспользоваться бесплатной альтернативой: freenom.com
Далее займемся сервером, где все это будет крутиться. Так как проект у нас небольшой, то и сервер нам сгодится небольшой. В идеале хватит VPS. Достать его можно в разных местах, например www.digitalocean.com
Итак, регистрируемся, создаем самый простой дроплет и ставим на него ubuntu (в моем случае это ubuntu 12.04, дальнейшие инструкции буду описывать для этой системы, но на остальных будет примерно то же)
Отлично, у нас есть сервер, пора залить на него наш проект.
Но не будем унывать, поставим себе новую версию:
Теперь настала очередь postgres’а. До этого мы использовали локальную версию на машине разработчика, теперь пришло время поставить СУБД на сервер.
Для этого сначала выполняем магическую последовательность команд:
Далее выполняем команду входа в psql:
И выходим c помощью команды \q
Редактируем файл /etc/postgresql/9.4/main/postgresql.conf, изменив строчку #listen_addresses = ‘localhost’ на listen_addresses = ‘*’
Тем самым мы сможем подключаться к postgresql извне с помощью pgadmin’а. Хотя, конечно, желательно этого избежать в целях безопасности, и когда все будет настроено и отлажено, отключить эту возможность.
Затем редактируем файл /etc/postgresql/9.4/main/pg_hba.conf
Должны быть добавлены две новых строчки и изменена одна строка для 127.0.0.1 следующим образом:
Я намеренно изменил md5 на trust, так как лично у меня были проблемы с запуском проекта, тем самым отключив проверку пароля для заданных адресов. Возможно у вас их не будет.
Теперь все настроено. Хотя тюнинговать постгрес можно до бесконечности, но ведь у нас всего лишь маленький проект, а значит, пока оставим как есть.
Перезапускаем postgres: и проверяем его работу.
Всё, с настройкой postgres’а закончили, что у нас дальше по сценарию?
В моем случае корневой директорией nginx была /etc/nginx. Там нам в первую очередь потребуется изменить файл /sites_available/default следующим образом:
Однако и это еще не все. Необходимо также модифицировать наш проект, чтобы он поддерживал настроенный нами прокси. Благо сделать это не трудно, достаточно лишь в application.properties добавить строки(не забудьте залить новую версию с изменениями):
Теперь можно запустить nginx командой service nginx start и затем попробовать запустить наш проект. Он будет доступен по ссылке сайта, либо же, если вы еще не приобрели домен, то по его ip-адресу, без указания порта.
Остался еще один небольшой штрих. Немного неудобно всегда стартовать проект тем способом, который был описан выше. Неплохо бы, чтобы при старте проекта консоль ввода на сервере освобождалась, приложение не закрывалось бы после выхода из ssh-сессии и чтобы где-нибудь велись логи приложения. Сделать это можно с помощью команды nohup. Предварительно создаем bash-скрипт, называя его script.sh:
Прописываем ему право на исполнение:
И запускаем командой:
Все, приложение запущено.
Теперь, если все сделано правильно, можно открыть сайт нашего проекта в браузере и насладиться результатом.
Введение в 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.