Определение устройства
Этот урок освещает процесс использования Spring для определения типа устройства, с которого зашли на ваш web-сайт.
Что вы создадите
Вы создадите Spring MVC приложение, которое будет определять тип устройства, с которого осуществляется доступ к вашему web-сайту и динамически переключать на отображение данных, соответствующих типу устройства.
Что вам потребуется
- Примерно 15 минут свободного времени
- Любимый текстовый редактор или IDE
- JDK 6 и выше
- Gradle 1.11+ или Maven 3.0+
- Вы также можете импортировать код этого урока, а также просматривать web-страницы прямо из Spring Tool Suite (STS), собственно как и работать дальше из него.
Как проходить этот урок
Как и большинство уроков по Spring, вы можете начать с нуля и выполнять каждый шаг, либо пропустить базовые шаги, которые вам уже знакомы. В любом случае, вы в конечном итоге получите рабочий код.
Чтобы начать с нуля, перейдите в Настройка проекта.
- Загрузите и распакуйте архив с кодом этого урока, либо кнонируйте из репозитория с помощью Git: git clone https://github.com/spring-guides/gs-device-detection.git
- Перейдите в каталог gs-device-detection/initial
- Забегая вперед, создайте автоконфигурацию
Когда вы закончите, можете сравнить получившийся результат с образцом в gs-device-detection/complete .
Настройка проекта
Для начала вам необходимо настроить базовый скрипт сборки. Вы можете использовать любую систему сборки, которая вам нравится для сборки проетов Spring, но в этом уроке рассмотрим код для работы с Gradle и Maven. Если вы не знакомы ни с одним из них, ознакомьтесь с соответсвующими уроками Сборка Java-проекта с использованием Gradle или Сборка Java-проекта с использованием Maven.
Создание структуры каталогов
В выбранном вами каталоге проекта создайте следующую структуру каталогов; к примеру, командой mkdir -p src/main/java/hello для *nix систем:
└── src └── main └── java └── hello
Создание файла сборки Gradle
Ниже представлен начальный файл сборки Gradle. Файл pom.xml находится здесь. Если вы используете Spring Tool Suite (STS), то можете импортировать урок прямо из него.
Если вы посмотрите на pom.xml , вы найдете, что указана версия для maven-compiler-plugin. В общем, это не рекомендуется делать. В данном случае он предназначен для решения проблем с нашей CI системы, которая по умолчанию имеет старую(до Java 5) версию этого плагина.
buildscript < repositories < maven < url "http://repo.spring.io/libs-release" >mavenLocal() mavenCentral() > dependencies < classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.6.RELEASE") >> apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'idea' apply plugin: 'spring-boot' jar < baseName = 'gs-device-detection' version = '0.1.0' >repositories < mavenLocal() mavenCentral() maven < url "http://repo.spring.io/libs-release" >> dependencies < compile("org.springframework.boot:spring-boot-starter-web") compile("org.springframework.mobile:spring-mobile-device") testCompile("junit:junit") >task wrapper(type: Wrapper)
Spring Boot gradle plugin предоставляет множество удобных возможностей:
- Он собирает все jar’ы в classpath и собирает единое, исполняемое «über-jar», что делает более удобным выполнение и доставку вашего сервиса
- Он ищет public static void main() метод, как признак исполняемого класса
- Он предоставляет встроенное разрешение зависимостей, с определенными номерами версий для соответсвующих Spring Boot зависимостей. Вы можете переопределить на любые версии, какие захотите, но он будет по умолчанию для Boot выбранным набором версий
Автоконфигурация
Включая Spring Mobile, Spring Boot настраивает DeviceResolverHandlerInterceptor и DeviceHandlerMethodArgumentResolver автоматически. DeviceResolverHandlerInterceptor находит User-Agent в заголовке входящего запроса и в зависимости от значения, определяет, откуда был выполнен запрос: обычный(desktop), мобильный(phone) или планшетный браузер. DeviceHandlerMethodArgumentResolver позволяет Spring MVC использовать распознанный Device объект в методе контроллера.
Создание web-контроллера
В Spring, конечной точкой web-обработки являются простые Spring MVC контроллеры. Ниже представлен Spring MVC контроллер, который обрабатывает GET запрос и возвращает строку со значением типа устройства:
package hello; import org.springframework.mobile.device.Device; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; @Controller public class DeviceDetectionController < @RequestMapping("/detect-device") public @ResponseBody String detectDevice(Device device) < String deviceType = "unknown"; if (device.isNormal()) < deviceType = "normal"; >else if (device.isMobile()) < deviceType = "mobile"; >else if (device.isTablet()) < deviceType = "tablet"; >return "Hello " + deviceType + " browser!"; > >В этом примере, вместо того, чтобы использовать представление(такое как JSP) для представления данных в HTML, этот контроллер просто возвращает информацию для записи прямо в тело ответа. В этом случае, данные — это строка «Hello mobile browser!», если запрос был с мобильного устройства. @ResponseBody аннотация говорит Spring MVC писать полученный объект в тело ответа, вместо того, чтобы отображать модель в представлении.
Создание приложения исполняемым
Несмотря на то, что пакет этого сервиса может быть в составе web-приложения и WAR файлов, более простой подход, продемонстрированный ниже создает отдельное самостоятельное приложение. Вы упаковываете все в единый, исполняемый JAR-файл, который запускается через хорошо знакомый старый main() Java-метод. Попутно, вы используете поддержку Spring для встроенного Tomcat контейнера сервлетов как HTTP среду выполнения вместо развертывания на сторонний экземпляр.
package hello; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.SpringApplication; import org.springframework.context.annotation.ComponentScan; @ComponentScan @EnableAutoConfiguration public class Application < public static void main(String[] args) < SpringApplication.run(Application.class, args); >>main() метод передает управление вспомогательному классу SpringApplication, где Application.class — аргумент его run() метода. Это сообщает Spring о чтении метаданных аннотации из Application и управлении ею как компонента в Spring application context.
Аннотация @ComponentScan говорит Spring’у рекурсивно искать в пакете hello и его потомках классы, помеченные прямо или косвенно Spring аннотацией @Component. Эта директива гарантирует, что Spring найдет и зарегистрирует GreetingController , потому что он отмечен @RestController , который, в свою очередь, является своего рода @Component аннотацией.
Аннотация @EnableAutoConfiguration переключает на приемлемое по умолчанию поведение, основанное на содержании вашего classpath. К примеру, т.к. приложение зависит от встраиваемой версии Tomcat (tomcat-embed-core.jar), Tomcat сервер установлен и сконфигурирован на приемлемое по умолчанию поведение от вашего имени. И т.к. приложение также зависит от Spring MVC (spring-webmvc.jar), Spring MVC DispatcherServlet сконфигурирован и зарегестрирован для вас — web.xml не нужен! Автоконфигурация полезный и гибкий механизм. Подробную информацию смотрите в API документации.
Сборка исполняемого JAR
Вы можете собрать единый исполняемый JAR-файл, который содержит все необходимые зависимости, классы и ресурсы. Это делает его легким в загрузке, версионировании и развертывании сервиса как приложения на протяжении всего периода разработки, на различных средах и так далее.
./gradlew build
Затем вы можете запустить JAR-файл:
java -jar build/libs/gs-device-detection-0.1.0.jar
Если вы используете Maven, вы можете запустить приложение, используя mvn spring-boot:run , либо вы можете собрать приложение с mvn clean package и запустить JAR примерно так:
java -jar target/gs-device-detection-0.1.0.jar
Процедура, описанная выше, создает исполняемый JAR. Вы также можете вместо него собрать классический WAR-файл.
Запуск сервиса
Если вы используете Gradle, вы можете запустить ваш сервис из командной строки:
./gradlew clean build && java -jar build/libs/gs-device-detection-0.1.0.jar
Если вы используете Maven, то можете запустить ваш сервис таким образом: mvn clean package && java -jar target/gs-device-detection-0.1.0.jar .
Как вариант, вы можете запустить ваш сервис напрямую из Gradle примерно так:
./gradlew bootRun
С mvn — mvn spring-boot:run .
Выходные данные отображены. Сервис должен быть поднят и запущен через несколько секунд.
Тестирование сервиса
Для тестирования приложения, зайдите по ссылке http://localhost:8080/detect-device в вашем браузере. В обычном браузере вы должны увидеть такое:
Если вы зайдете с браузера мобильного телефона по тому же URL, вы должны такое:
Если вы зайдете с браузера планшетного ПК по тому же URL, вы должны такое:
Обратите внимание, что если вы захотите использовать реальное мобильное устройство для тестирования этого контроллера, то он не будер работать с localhost сервером. Для этого вам нужно узнать имя вашей машины в вашей сети и использовать его вместо localhost.
Итог
Поздравляем! Вы только что разработали простую web-страницу, которая определяет тип устройства, которое используется клиентом.
С оригинальным текстом урока вы можете ознакомиться на spring.io.
Application Version Info — получить версию приложения
Иногда бывает необходимость получить текущую версию приложения на SpringBoot + Gradle и при каждой сборке проекта увеличивать ее на 1 и возможно в дальнейшем отображать эту версию приложения на UI.
Я решил написать эту статью именно для Gradle, потому что для Maven есть специальный плагин, с помощью которого можно это сделать, а также есть много статей на эту тему.
Исходный код будет в конце статьи.
С увеличением версии я разобрался скриптом на Groovy следующим образом
В файле buil.gradle добавьте следующий скрипт
tasks.register("incrementVersion") doFirst def ver = version
println ver
String lastNumber = ver.substring(ver.lastIndexOf('.') + 1)
int increment = lastNumber.toInteger() + 1
println increment
String firstNumber = ver.substring(0, ver.lastIndexOf("."))
println firstNumber
String result = buildFile.getText().replaceFirst("version='$version'","version='" + firstNumber + "." + increment + "'")
buildFile.setText(result)
>
>
Вы должны указать зависимость вашей задачи incrementVersion по отношению к задаче build. Те, при выполнении задачи build, ваша задача incrementVersion будет выполнена первой, и, таким образом, новое значение версии будет сохранено в вашем файле build.gradle.
Добавьте это после вашего скрипта
jar.dependsOn incrementVersion
bootJar.dependsOn incrementVersion
или просто вот такую запись
build.dependsOn incrementVersion
Затем вы должны указать ту информацию, которая должна отображаться в вашем файле манифеста
bootJar doFirst manifest attributes(
'Main-Class': 'com.example.appinfo.AppinfoApplication',
'Implementation-Title': 'Application Info project',
'Implementation-Version': "$"
)
>
>
>
В моем случае это Implementation-Title и Implementation-Version.
Я также изменил значение своей версии на следующее
version='0.0.1'
И в итоге мой build.gradle файл выглядит следующий образом
plugins id 'org.springframework.boot' version '2.1.6.RELEASE'
id 'java'
>
tasks.register("incrementVersion") doFirst def ver = version
println ver
String lastNumber = ver.substring(ver.lastIndexOf('.') + 1)
int increment = lastNumber.toInteger() + 1
println increment
String firstNumber = ver.substring(0, ver.lastIndexOf("."))
println firstNumber
String result = buildFile.getText().replaceFirst("version='$version'","version='" + firstNumber + "." + increment + "'")
buildFile.setText(result)
>
>
jar.dependsOn incrementVersion
bootJar.dependsOn incrementVersion
apply plugin: 'io.spring.dependency-management'
bootJar doFirst manifest attributes(
'Main-Class': 'com.example.appinfo.AppinfoApplication',
'Implementation-Title': 'Application Info project',
'Implementation-Version': "$"
)
>
>
>
group = 'com.example'
version='0.0.8'
sourceCompatibility = '1.8'
configurations developmentOnly
runtimeClasspath extendsFrom developmentOnly
>
>
repositories mavenCentral()
>
dependencies implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-web-services'
developmentOnly 'org.springframework.boot:spring-boot-devtools'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
>
Теперь осталось написать логику, по которой мы получим эту версию после сборки проекта.
Создайте класс контроллера со следующим методом
import com.example.ApplicationInfo.util.AppInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class AppInfoResource
@Autowired
private AppInfo appInfo;
@GetMapping("/")
public String getAppInfo() String manifestInfo = appInfo.getManifestInfo();
if (manifestInfo == null) return "start jar file and go to localhost:8080";
>
return manifestInfo;
>
>
И собственно сам класс AppInfo
import org.springframework.stereotype.Component;
@Component
public class AppInfo
public String getManifestInfo() return getClass().getPackage().getImplementationVersion();
>
>
Здесь мы получаем нашу новую версию (к которой была прибавлена 1) после сборки проекта.
Тестируем:
В командной строке в корне проекта
gradle build
ваш файл манифеста появится по пути в корне проекта
/build/tmp/bootJar/MANIFEST.MF
Ваш jar будет в
/build/libs/
В файле манифеста вы увидите информацию
Manifest-Version: 1.0
Implementation-Title: Application Info project
Implementation-Version: 0.0.2
Start-Class: com.example.ApplicationInfo.ApplicationInfoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Spring-Boot-Version: 2.1.6.RELEASE
Main-Class: com.example.appinfo.AppinfoApplication
Точно такой же файл будет в вашем jar-файле.
Теперь запустите приложение или запустите созданный только-что jar файл из командной строки и перейдите по
Вы увидите версию приложения из файла MANIFEST.MF из jar файла.
Если вы пересоберете проект, то увидите уже новую версию (+1).
Дальше вы сможете делать что вам угодно, вплоть до того, чтобы передать эту версию на UI и т.д.
Надеюсь данная статья была полезна.
Если вы нашли неточности в описании данной статьи, вы можете написать мне на email и я с радостью вам отвечу.
Kirill Sereda
Обзор Spring Framework
Spring упрощает создание корпоративных приложений с использованием Java. Он предоставляет все необходимое для использования языка Java в корпоративной среде, в том числе поддержку Groovy и Kotlin в качестве альтернативных языков в JVM, а также предлагает гибкость для создания множества видов архитектур в зависимости от потребностей приложения. Начиная со Spring Framework 5.1, Spring требует JDK 8+ (Java SE 8+) и обеспечивает встроенную поддержку JDK 11 LTS. Обновление Java SE 8 update 60 предлагается использовать в качестве минимально допустимого релиза исправлений для Java 8, но обычно рекомендуется использовать самый свежий релиз исправлений.
Spring поддерживает широкий спектр сценариев применения. На крупном предприятии приложения часто используются в течение длительного времени и должны выполняться на JDK и сервере приложений, цикл обновления которых находится вне контроля разработчика. Одни могут работать как единый jar-файл на встроенном сервере, возможно, в облачной среде. Иные могут представлять собой автономные приложения (например, пакетные или интеграционные рабочие нагрузки), которым не нужен сервер.
Spring предоставляет открытый исходный код. У него есть большое и активное сообщество, которое предоставляет постоянную обратную связь, основанную на широком спектре реальных сценариев использования. Это помогло Spring успешно развиваться в течение очень долгого времени.
Что мы подразумеваем под «Spring»
Термин «Spring» означает разные вещи в разных контекстах. Его можно использовать для обозначения самого проекта Spring Framework, с которого все началось. Со временем другие проекты Spring были созданы поверх Spring Framework. Чаще всего, когда люди говорят «Spring», они имеют в виду все семейство проектов. Данная справочная документация сосредоточена на основе: самом фреймоврке Spring Framework.
Spring Framework разделен на модули. Приложения могут выбирать, какие модули им нужны. В основе лежат модули основного контейнера, включая модель конфигурации и механизм внедрения зависимостей (Dependency Injection (DI)). Помимо этого, Spring Framework обеспечивает базовую поддержку различных архитектур приложений, включая обмен сообщениями, транзакционные данные и хранимость, а также веб. Он также включает в себя веб-фреймворк Spring MVC на основе сервлетов и, параллельно, реактивный веб-фреймворк Spring WebFlux.
Примечание о модулях: jar-файлы фреймворка Spring позволяют развертывать их по пути к модулю JDK 9 («Jigsaw»). Для использования в приложениях с поддержкой Jigsaw jar-файлы Spring Framework 5 поставляются с записями манифеста «Automatic-Module-Name», которые определяют стабильные имена модулей на уровне языка («spring.core», «spring.context» и т.д.), независимые от имен артефактов jar (jar-файлы имеют одинаковый шаблон именования с «-» вместо «.», например «spring-core» и «spring-context»). Конечно, jar-файлы фреймоврка Spring все еще нормально работают с classpath как в JDK 8, так и в 9+.
История Spring и Spring Framework
Spring появился на свет в 2003 году как реакция на сложность ранних спецификаций J2EE. Хотя некоторые считают, что Java EE и Spring являются конкурентами, Spring, по сути, дополняет Java EE. Модель программирования Spring не охватывает спецификацию платформы Java EE; скорее, она интегрируется с тщательно отобранными отдельными спецификациями из обобщенной EE:
- Servlet API (JSR 340)
- WebSocket API (JSR 356)
- Утилиты параллелизма (JSR 236)
- JSON Binding API (JSR 367)
- Bean Validation (JSR 303)
- JPA (JSR 338)
- JMS (JSR 914)
- а также конфигурации JTA/JCA для координации транзакций, если это необходимо.
Spring Framework также поддерживает спецификации внедрения зависимостей (JSR 330) и общих аннотаций (JSR 250), которые разработчики приложений могут использовать вместо специфичных для Spring механизмов, предоставляемых Spring Framework.
Начиная со Spring Framework 5.0, Spring требует, как минимум, уровня Java EE 7 (например, Servlet 3.1+, JPA 2.1+), в то же время предоставляю встроенную интеграцию с новыми API на уровне Java EE 8 (например, Servlet 4.0, JSON Binding API), когда встречается во время выполнения. Это обеспечивает полную совместимость Spring, например, с Tomcat 8 и 9, WebSphere 9 и JBoss EAP 7.
Со временем роль Java EE в разработке приложений эволюционировала. В первые дни существования Java EE и Spring приложения создавались для развертывания на сервере приложений. Сегодня с помощью Spring Boot приложения создаются удобным для devops и облачных вычислений способом с помощью встроенного контейнера сервлетов, который легко изменить. Начиная со Spring Framework 5, приложение WebFlux даже не использует Servlet API напрямую и может запускаться на серверах (таких как Netty), которые не являются контейнерами сервлетов.
Spring продолжает внедрять инновации и развиваться. Помимо Spring Framework, существуют и другие проекты, такие как Spring Boot, Spring Security, Spring Data, Spring Cloud, Spring Batch и т.д. Важно помнить, что каждый проект имеет свои собственные репозиторий исходного кода, систему отслеживания ошибок и частоту релиза новых версий. См. spring.io/projects для ознакомления с полным списком проектов Spring.
Принцип проектирования
Когда вы изучаете фреймворк, важно понимать не только то, что он делает, но и по каким принципам он работает. Вот основные принципы работы Spring Framework:
- Выбор на каждом уровне. Spring позволяет откладывать проектные решения на «как можно позже». Например, вы можете переключать поставщиков решений для хранения данных с помощью системных настроек, не меняя свой код. То же самое относится и ко многим другим проблемам инфраструктуры и интеграции со сторонними API.
- Учет различных точек зрения. Spring предполагает гибкость и отсутствие жестко заданного подхода к тому, как что-либо нужно делать. Он предлагает решения для широкого спектра прикладных потребностей с различным видением.
- Поддержка высокого уровня обратной совместимости. Эволюционное развитие Spring было тщательно продумано таким образом, чтобы вносить несколько существенных изменений между версиями. Spring поддерживает тщательно подобранный набор версий JDK и сторонних библиотек для облегчения обслуживания приложений и библиотек, зависящих от Spring.
- забоченность проектированием API. Команда Spring тратит много времени и сил на создание интуитивно понятных API, которые сохраняют работоспособность во многих версиях и в течение многих лет.
- Высокие стандарты качества кода. Spring Framework делает сильный акцент на содержательном, актуальном и точном javadoc. Это один из очень немногих проектов, который может претендовать на чистую структуру кода без циклических зависимостей между пакетами.
Обратная связь и вклад в развитие
Для поиска ответов на практические вопросы, диагностики или отладки мы предлагаем использовать Stack Overflow. Нажмите здесь, чтобы ознакомиться со списком предлагаемых тегов для использования в Stack Overflow. Если вы совершенно уверены, что в Spring Framework есть проблема, или хотели бы предложить какую-либо функцию, пожалуйста, воспользуйтесь GitHub Issues.
Если у вас есть на примете решение или предлагаемое исправление, вы можете отправить запрос на включение на Github. Однако, пожалуйста, имейте в виду, что по всем вопросам, кроме самых тривиальных, мы ожидаем, что запрос будет отправлен в систему отслеживания ошибок, где проводятся обсуждения и оставляется запись для дальнейшего использования
Для получения более подробной информации ознакомьтесь с руководящими принципами на странице проекта верхнего уровня «ВКЛАД В РАЗВИТИЕ».
Начало работы
Если вы только приступаете к работе со Spring, то можете начать использовать Spring Framework, создав приложение на основе Spring Boot. Проект Spring Boot предлагает быстрый (и жестко заданный) способ создания готового к работе приложения на основе Spring. Он основан на Spring Framework, предпочтение в нем отдается соглашению, а не конфигурации, и предназначен он для того, чтобы дать возможность как можно скорее приступить к работе.
Вы можете использовать start.spring.io для создания базового проекта или следовать одному из руководств по «Началу работы», например «Начало создания веб-службы RESTful». Помимо того, что эти руководства легче усваиваются, они очень ориентированы на конкретные задачи, и большинство из них основаны на Spring Boot. Они также охватывают другие проекты из портфолио Spring, с которыми вы, возможно, захотите ознакомиться при решении конкретной проблемы.
Как узнать версии зависимостей, используемые в Spring Boot?
Я знаю, что можно зайти на страницу проекта Spring Boot, там в разделе Learn найти нужную версию бута, щелкнуть по ссылке «Reference Doc > Dependency versions» и на открывшейся странице будут все зависимости и их версии. Но мне хотелось бы разобраться, как определить версии, используя git репозиторий бута. Я нашел файл сборки graddle, там какие-то версии есть, но я не уверен, то ли это. Например, там не ищется spring-security-core, spring-web и т.д. В общем, хочу разобраться как, имея на руках pom, сгенерированный на start.spring.io
org.springframework.boot spring-boot-starter-parent 3.2.0-M1 . org.springframework.boot spring-boot-starter-security org.springframework.boot spring-boot-starter-web org.projectlombok lombok true понять через git репозиторий бута, какие именно зависимости входят в spring-boot-starter-security, spring-boot-starter-web и какие у этих зависимостей версии.
Отслеживать
задан 9 авг в 11:59
slarkwithskadi slarkwithskadi