Пользовательские Компоненты Пружинной Загрузки

Философия Spring Boot заключается в разработке приложений путем создания независимых , модульных и легко настраиваемые компоненты . Spring Boot предоставляет интеллектуальные и простые механизмы и соглашения для создания таких компонентов, которые могут быть легко применены в пользовательских проектах.

В этом посте мы рассмотрим эти идеи и покажем, как создавать доменно-ориентированные пользовательские компоненты способом загрузки Spring.

Что Такое Весенний Ботинок

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

Зависимости согласуются друг с другом и тестируются в процессе интеграции.

Для веб-приложений включены встроенные серверы (Tomcat, Jetty, Undertow). Возможно даже традиционное развертывание в контейнер приложения, по умолчанию Spring Boot является автономным, все включено в окончательный JAR, и никакая дополнительная инфраструктура не требуется (за исключением JDK, очевидно).

Кроме того, Spring Boot поставляется с множеством готовых к работе функций , таких как регистраторы, метрики, аудит, отслеживание и мониторинг.

Простой скелет приложения может быть легко прототипирован с помощью Spring Initializr .

Построение Систем

Пружинный ботинок предлагает Грейдл и Maven плагины для упаковки и запуска приложений Spring Boot. Также можно создавать и публиковать изображения докеров с помощью плагинов.

Сортировка

Пружинный ботинок поставляется с org.springframework.загрузочный и io.spring.управление зависимостями плагины:

plugins {
  id 'org.springframework.boot' version '2.5.0'
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

В качестве альтернативы, только управление зависимостями может использоваться изолированно:

plugins {
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}

dependencyManagement {
  dependencies {
    dependency 'org.springframework:spring-core:5.3.0'
  }
}

Знаток

Как правило, ваш POM-файл Maven наследуется от родительского проекта |/spring-boot-starter-/|:

  org.springframework.boot
  spring-boot-starter-parent
  2.5.0

Родительский POM предоставляет плагин Spring Boot, управление зависимостями и другие разумные настройки по умолчанию. Все настройки по умолчанию могут быть перезаписаны в вашем POM.

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

  
    
      org.springframework.boot
      spring-boot-dependencies
      2.5.0
      pom
      import
    
  

Обзор функций

Spring Boot представляет несколько новых функций для экосистемы Spring.

Приложение Для Весенней Загрузки

Класс Spring Application предоставляет удобный способ начальной загрузки приложения Spring, которое запускается из метода main() .

Когда аннотация @SpringBootApplication включена в основной класс, приложение загружается, автоматическая настройка включена и Сканирование компонентов Spring настроено на текущий пакет в качестве корневого.

Рекомендуется размещать класс приложения в корневом пакете выше других классов. Таким образом, пакет определяет базу поиска для сканирования компонентов.

org.example.myshop
+- MyShopApplication
+- catalog
+- delivery
+- order
...

Стартеры

Стартеры – это набор удобных дескрипторов зависимостей, которые вы можете включить в свое приложение.

Стартеры привносят в приложение все необходимые зависимости и конфигурации:

dependencies {
  implementation 'org.springframework.boot:spring-boot-starter-web'
}

Все стартеры имеют основной стартер spring-boot-starter прямую зависимость, которая включает поддержку автоматической настройки, ведение журнала и YAML.

Стартеры – это часть философии Spring Boot, удобный способ включения компонентов в ваше приложение.

Автоматическая настройка

Автоматическая настройка загрузки Spring пытается автоматически настроить приложение Spring на основе добавленных зависимостей jar.

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

Большинство стандартных автоконфигураций Spring легко настраиваются с помощью свойств .

Свойства приложения

Spring Boot автоматически находит и загружает приложение[-профиль].(свойства|yaml|yml) из пути к классу и других значений по умолчанию местоположения .

Свойства из загруженных файлов добавляются в среду Spring.

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

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

# application.yml

spring:
  datasource:
    url: jdbc:postgresql://db:5432/test
    username: admin
    password: secret

Пользовательские Компоненты

Функции Spring Boot могут служить обычным шаблоном для пользовательских компонентов. Чтобы все делать правильно, необходимо более глубокое знание концепций и механизмов Spring Boot.

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

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

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

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

Структура Кода

Мы будем использовать пакеты Java для структурирования кода по модулям домена и Maven или подпроектам Gradle для технических сокращений.

Каждый компонент представляет собой автономную службу бизнес-возможностей , предоставляющую множество артефактов для API и реализации, сформированных физическими модулями.

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

delivery/   -- comp. root
+- domain/  -- domain API
+- events/  -- events API
+- jdbc/    -- JDBC impl
+- rest/    -- Restful API
+- spring-boot-starter/ -- starter
+- pom.xml
+- build.gradle
\- settings.gradle

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

В сценарии с одним приложением на корневом уровне создается отдельный модуль для приложения Spring Boot:

myshop/
+- application/
+- catalog/
+- delivery/
+- order/
...

В сценарии с микросервисами каждый компонент имеет свой собственный прикладной модуль:

myshop/
+- catalog/
|  +- application/
|  +- domain/
|  +- jdbc/
|  +- rest/
|  \- spring-boot-starter/
+- delivery/
|  +- application/
|  +- domain/
|  +- events/
|  +- jdbc/
|  +- rest/
|  \- spring-boot-starter/
+- order/
|  +- application/
|  +- domain/
|  +- events/
|  +- jdbc/
|  +- rest/
|  \- spring-boot-starter/
...

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

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

Например, даже если модуль REST построен на Spring Web, должна быть включена только соответствующая зависимость Spring framework:

// rest/build.gradle

implementation 'org.springframework:spring-web'

Веб-стартер Spring Boot будет включен только в модуль starter:

// spring-boot-starter/build.gradle

implementation 'org.springframework.boot:spring-boot-starter-web'

Пакеты Java

Поскольку мы создаем доменно-ориентированные компоненты, пакеты также должны управляться доменом.

Все модули компонента должны иметь общий корневой пакет. Модули могут быть дополнительно структурированы с помощью функции домена или технического аспекта. Одни и те же функции должны быть включены в идентичный пакет.

Эта стратегия позволяет скрывать информацию о классах реализации с помощью специальных возможностей пакета Java. Рассмотрим пример, где ○ и ● средний публичный и защищенный от упаковки , соответственно:

delivery/
+- domain/
|  \- src/main/java/
|     \- org.example.myshop.delivery
|        \- ○DeliveryService.java
+- events/
|  \- src/main/java/
|     \- org.example.myshop.delivery
|        \- ○DeliveryDispatched.java
+- jdbc/
|  \- src/main/java/
|     \- org.example.myshop.delivery.jdbc
|        \- ●DeliveryServiceJdbc.java
+- rest/
|  \- src/main/java/
|     \- org.example.myshop.delivery.rest
|        \- ●DeliveryRestController.java
\- spring-boot-starter/
   \- src/main/java/
      \- org.example.myshop.delivery
         \- jdbc
            \- ●DeliveryJdbcConfig.java
         \- rest
            \- ●DeliveryRestConfig.java

Классы Служба Доставки Jdbc и Контроллер RestController доставки находятся в том же пакете, что и Конфигурация Jdbc доставки и Testconfig доставки , соответственно. Это делает их доступными для классов конфигурации, которые являются единственным местом, откуда они должны быть доступны, и скрыты для остального мира.

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

Изготовленный на Заказ Пружинный Загрузочный Стартер

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

По соглашению, имя стартера начинается с имени компонента, за которым следует -spring-boot-starter суффикс:

org.example.myshop:delivery-spring-boot-starter

Автоматические конфигурации

Точкой входа для запуска загрузки Spring является файл META-INF/spring.factories . Spring Boot проверяет наличие файла в опубликованной вами банке данных. В файле должны быть перечислены классы автоматической настройки компонентов под ключом EnableAutoConfiguration :

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  org.example.myshop.delivery.DeliveryConfiguration

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

Под капотом автоматическая настройка реализована с помощью стандартных @Configuration классов. Несколько классов конфигурации могут быть составлены с помощью @Import аннотации:

@Configuration
@Import(JdbcDeliveryConfiguration.class)
class DeliveryConfiguration {
  ...
}

Автоматическая конфигурация создает и регистрирует все необходимые компоненты Spring для конкретного компонента.

Стартер компонента – это единственное место, где должны существовать конфигурации. Другие модули служат другим целям.

Зависимости

Загрузочный стартер Spring содержит все зависимости, необходимые для компонента в целом.

Если, например, компонент содержит модуль с контроллерами Spring Web restful, стартер должен содержать соответствующий стартер Spring Boot для web:

implementation 'org.springframework.boot:spring-boot-starter-web'

Минимальная зависимость, которую должен включать каждый стартер Spring Boot, – это стартер ядра Spring Boot:

implementation 'org.springframework.boot:spring-boot-starter'

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

implementation 'org.example.myshop:catalog-spring-boot-starter'
implementation 'org.example.myshop:delivery-spring-boot-starter'
implementation 'org.example.myshop:order-spring-boot-starter'
...

Свойства конфигурации

Spring Boot предоставляет альтернативный метод работы со свойствами, который позволяет строго типизированным компонентам управлять и проверять конфигурацию вашего приложения.

@ConfigurationProperties(
    prefix = "myshop.delivery")
@Setter
@Getter
class DeliveryProperties {

  private String cargoName;
  private String dateFormat;
}

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

@Configuration
@EnableConfigurationProperties(
DeliveryProperties.class)
class DeliveryConfiguration {

  @Bean
  DeliveryService deliveryService(
      DeliveryProperties properties
  ) {
    return new DeliveryServiceImpl(
      properties.getCargoName(),
      properties.getDateFormat()
    );
  }
}

Приложение Spring Boot определяет структуру конфигурации со значениями по умолчанию:

# application.yml

myshop:
  delivery:
    cargo-name: PPL
    date-format: yyyy-mm-dd
  order:
    prefix-id: OrderID

Значения по умолчанию могут быть перезаписаны во время выполнения, например, с помощью переменных среды:

MYSHOP_DELIVERY_CARGO_NAME=DHL

Вывод

Пружинный ботинок – отличный инструмент для разработки модульный монолитный и микросервисы приложения.

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

Стартеры Spring Boot содержат конфигурации и зависимости для компонентов и определяют структуру конфигурации с помощью свойств конфигурации с выделенными пространствами имен.

Приложение Spring Boot собирает компоненты и дополнительно обеспечивает сквозные задачи.

Пример

Пример кода богатого модульного загрузочного приложения Spring можно найти на моем GitHub .

Связи

• Справочная документация по Пружинной загрузке
• Справочное руководство по плагину Spring Boot Gradle
• Документация по плагину Maven для весенней загрузки
• Начало Работы С Spring Boot
• Использование Пружинного Ботинка
• Инструкции по установке пружинного ботинка
• Создание Собственной Автоматической конфигурации
• Весенний Инициализр

Первоначально опубликовано в моем блоге .

Оригинал: “https://dev.to/ttulka/spring-boot-custom-components-300h”