Рубрики
Без рубрики

Тонкие банки с пружинным ботинком

Узнайте, как сделать тонкую банку с помощью Spring Boot Thin Launcher.

Автор оригинала: Alessio Stalla.

1. введение

В этом уроке мы рассмотрим как создать проект Spring Boot в тонкий файл JAR, используя spring-boot-this-launcher project.

Spring Boot известен своими “жирными” развертываниями JAR, где один исполняемый артефакт содержит как код приложения, так и все его зависимости.

Boot также широко используется для разработки микросервисов. Иногда это может противоречить подходу “жирной БАНКИ”, потому что включение одних и тех же зависимостей снова и снова во многие артефакты может стать важной тратой ресурсов.

2. Предварительные условия

Прежде всего, конечно, нам нужен проект Spring Boot. В этой статье мы рассмотрим сборки Maven и сборки Gradle в их наиболее распространенных конфигурациях.

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

2.1. Проекты Maven

В загрузочном проекте, построенном с помощью Maven, мы должны настроить плагин Spring Boot Maven в вашем проекте pom.xml файл, его родитель или один из его предков:


    org.springframework.boot
    spring-boot-maven-plugin

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


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

2.2. Проекты Gradle

В загрузочном проекте, построенном с помощью Gradle, у нас будет плагин Boot Gradle:

buildscript {
    ext {
        springBootPlugin = 'org.springframework.boot:spring-boot-gradle-plugin'
        springBootVersion = '2.4.0'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("${springBootPlugin}:${springBootVersion}")
    }
}

// elided

apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

springBoot {
    mainClassName = 'com.baeldung.DemoApplication'
}

Обратите внимание, что в этой статье мы рассмотрим только проекты Boot 2.x и более поздние версии. Тонкий лаунчер также поддерживает более ранние версии, но для этого требуется немного другая конфигурация Gradle, которую мы опускаем для простоты. Пожалуйста, посмотрите на домашнюю страницу проекта для получения более подробной информации.

3. Как создать тонкую БАНКУ?

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

Итак, когда мы строим проект с библиотекой, мы получаем файл JAR с нашим кодом, файл, перечисляющий его зависимости, и основной класс из библиотеки, который выполняет вышеуказанные задачи.

Конечно, все немного более тонко, чем наше упрощенное объяснение; мы подробно обсудим некоторые темы позже в этой статье.

4. Основное использование

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

Мы запустим приложение с обычным java-jar , с дополнительными дополнительными аргументами командной строки, которые управляют тонкой пусковой установкой. Мы увидим несколько из них в следующих разделах; домашняя страница проекта содержит полный список.

4.1. Проекты Maven

В проекте Maven мы должны изменить объявление загрузочного плагина (см. раздел 2.1), чтобы включить зависимость от пользовательского “тонкого” макета:


    org.springframework.boot
    spring-boot-maven-plugin
    
        
        
            org.springframework.boot.experimental
            spring-boot-thin-layout
            1.0.11.RELEASE

пусковая установка будет считывать зависимости из pom.xml файл, который Maven хранит в сгенерированной банке в каталоге META-INF/maven .

Мы выполним сборку как обычно, например, с помощью установка mvn .

Если мы хотим иметь возможность создавать как тонкие, так и толстые сборки (например, в проекте с несколькими модулями), мы можем объявить пользовательский макет в выделенном профиле Maven.

4.2. Maven и зависимости: тонкие свойства

Мы также можем заставить Maven генерировать файл thin.properties в дополнение к pom.xml . В этом случае файл будет содержать полный список зависимостей, включая транзитивные, и пусковая установка предпочтет его pom.xml .

Mojo (плагин) для этого – spring-boot-thin-maven-plugin:properties, и по умолчанию он выводит файл thin.properties в src/main/resources/META-INF , но мы можем указать его местоположение с помощью свойства thin.output :

$ mvn org.springframework.boot.experimental:spring-boot-thin-maven-plugin:properties -Dthin.output=.

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

4.3. Проекты Gradle

В проекте Gradle вместо этого мы добавляем специальный плагин:

buildscript {
    ext {
        //...
        thinPlugin = 'org.springframework.boot.experimental:spring-boot-thin-gradle-plugin'
        thinVersion = '1.0.11.RELEASE'
    }
    //...
    dependencies {
        //...
        classpath("${thinPlugin}:${thinVersion}")
    }
}

//elided

apply plugin: 'maven'
apply plugin: 'org.springframework.boot.experimental.thin-launcher'

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

~/projects/baeldung/spring-boot-gradle $ ./gradlew thinJar

4.4. Gradle и зависимости: pom.xml

В примере кода в предыдущем разделе мы объявили плагин Maven в дополнение к тонкой пусковой установке (а также плагины для загрузки и управления зависимостями, которые мы уже видели в разделе Предварительные условия).

Это потому, что, как и в случае с Maven, который мы видели ранее, артефакт будет содержать и использовать pom.xml файл с перечислением зависимостей приложения. В pom.xml файл генерируется задачей под названием это стихотворение , которая является неявной зависимостью любой задачи jar.

Мы можем настроить сгенерированный pom.xml файл с выделенной задачей. Здесь мы просто повторим то, что уже делает тонкий плагин автоматически:

task createPom {
    def basePath = 'build/resources/main/META-INF/maven'
    doLast {
        pom {
            withXml(dependencyManagement.pomConfigurer)
        }.writeTo("${basePath}/${project.group}/${project.name}/pom.xml")
    }
}

Чтобы использовать наш обычай pom.xml файл, мы добавляем вышеуказанную задачу к зависимостям задачи jar:

bootJar.dependsOn = [createPom]

4.5. Gradle и зависимости: тонкие.свойства

Мы также можем заставить Gradle генерировать файл thin.properties , а не pom.xml , как мы делали ранее с Maven.

Задача, которая создает файл this.properties , называется thin Properties, и по умолчанию не используется. Мы можем добавить его в качестве зависимости от задачи jar:

bootJar.dependsOn = [thinProperties]

5. Хранение Зависимостей

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

В частности, тонкая пусковая установка использует инфраструктуру Maven для разрешения зависимостей, поэтому:

  1. он проверяет локальный репозиторий Maven, который по умолчанию находится в ~/.m2/repository , но может быть перемещен в другое место;
  2. затем он загружает отсутствующие зависимости из Maven Central (или любого другого настроенного репозитория);
  3. наконец, он кэширует их в локальном репозитории, так что ему не придется загружать их снова при следующем запуске приложения.

Конечно, фаза загрузки-это медленная и подверженная ошибкам часть процесса, потому что она требует доступа к Maven Central через Интернет или доступа к локальному прокси-серверу, и мы все знаем, что эти вещи, как правило, ненадежны.

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

5.1. Запуск Приложения для разминки

Самый простой способ кэширования зависимостей-выполнить прогрев приложения в целевой среде. Как мы видели ранее, это приведет к загрузке и кэшированию зависимостей в локальном репозитории Maven. Если мы запустим более одного приложения, репозиторий в конечном итоге будет содержать все зависимости без дубликатов.

Поскольку запуск приложения может иметь нежелательные побочные эффекты, мы также можем выполнить “сухой запуск”, который только разрешает и загружает зависимости без запуска какого-либо пользовательского кода:

$ java -Dthin.dryrun=true -jar my-app-1.0.jar

Обратите внимание, что в соответствии с соглашениями о весенней загрузке мы можем установить -Dthin.dryrun свойство также с –thin.аргумент командной строки dryrun для приложения или с системным свойством THIN_DRYRUN . Любое значение, кроме false , проинструктирует тонкую пусковую установку выполнить сухой запуск.

5.2. Упаковка зависимостей Во время сборки

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

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

Формат, в котором Тонкий плагин для Maven и Gradle упаковывает зависимости во время сборки, совпадает с локальным репозиторием Maven:

root/
    repository/
        com/
        net/
        org/
        ...

Фактически, мы можем указать приложению, использующему тонкую пусковую установку, на любой такой каталог (включая локальный репозиторий Maven) во время выполнения со свойством thin.root :

$ java -jar my-app-1.0.jar --thin.root=my-app/deps

Мы также можем безопасно объединить несколько таких каталогов, скопировав их один над другим, таким образом, получив репозиторий Maven со всеми необходимыми зависимостями.

5.3. Упаковка Зависимостей С Помощью Maven

Чтобы Maven упаковал зависимости для нас, мы используем resolve цель spring-boot-thin-maven-плагина. Мы можем вызвать его вручную или автоматически в вашем pom.xml:


    org.springframework.boot.experimental
    spring-boot-thin-maven-plugin
    ${thin.version}
    
        
        
        resolve
        
            resolve
        
        false

После создания проекта мы найдем каталог target/thin/root/ со структурой, которую мы обсуждали в предыдущем разделе.

5.4. Упаковка Зависимостей С Помощью Gradle

Если мы используем Gradle с плагином thin-launcher , вместо этого у нас есть доступная задача thin Resolve . Задача сохранит приложение и его зависимости в каталоге build/the/root/ , аналогично плагину Maven из предыдущего раздела:

$ gradlew thinResolve

Обратите внимание, что на момент написания статьи в плагине thing-launcher была ошибка, которая не позволяет сохранять зависимости, если используется thin.properties : https://github.com/dsyer/spring-boot-thin-launcher/issues/53 .

6. Выводы и дальнейшее чтение

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

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

Реализация всех примеров Maven и фрагментов кода может быть найдена в проекте GitHub – как проект Maven, поэтому его должно быть легко импортировать и запускать как есть.

Аналогично, все примеры Gradle ссылаются на этот проект GitHub .

Читайте ещё по теме: