Как писать на spring в 2017

Особенности 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 — делает установку и развертывание приложения значительно проще

Основные концепции

  • Mono
    Класс Mono нужен для работы с единственным объектом. Давайте посмотрим, как будет выглядеть простое приложение с использованием Mono. Для этого создадим проект и сущность User в нем(все настройки и примеры можно найти на моем профиле в github):

    Далее создадим класс с тестами и подготовленными пользователями:

    Напишем тест:

    Как видно из примера, использовать реактивный подход довольно просто.
    Кроме того, у класса Mono есть множество методов на любой случай жизни. Например, есть всем известный метод map для преобразования одного типа в другой:

  • Flux
    Данный класс схож с Mono, но предоставляет возможность асинхронной работы со множеством объектов:

    Как и в случае с Mono у Flux есть набор полезных методов:

    Здесь следует подчеркнуть одну особенность. В отличае от стандартных(не демонов) потоков при завершении работы основного потока выполнения сбор наших данных останавливается, и программа завершается. Это можно легко продемострировать. Следующий код ничего не выведет на консоль:

    Этого можно избежать с помощью класса CountDownLatch:

рективностивной системы реактивного программированияP.S.систему обмена сообщениямисистемой сообщений

@EnableAutoConfiguration

Эта аннотация включает автоконфигурацию. И здесь, пожалуй, ключевой момент в развенчании магии Spring. Вот как объявлена эта аннотация:

Т.е. это самый обычный импорт конфигурации, про который мы говорили выше. Класс же (и его преемник в Spring Boot 1.5+ — ) это просто конфигурация, которая добавит несколько бинов в контекст. Однако, у этого класса есть одна тонкость — он не объявляет бины сам, а использует так называемые фабрики.

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

Кусочек файла (он находится в папке внутри ), который нам сейчас нужен это:

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

По сути, ее можно заменить на ручной импорт нужных конфигураций:

Однако, особенность в том, что Spring Boot пытается применить все конфигурации (а их около сотни). Я думаю, у внимательного читателя уже появилась пара вопросов, которые стоит прояснить.

  • «Но это же медленно!». И да, и нет — под рукой нет точных цифр, но сам по себе процесс автоконфигурации очень быстрый (порядка сотни миллисекунд на абстрактной машине в вакууме)

  • «Но это же излишне, зачем мне конфигурить Rabbit () если я его не использую?». Наличие автоконфигурции не значит, что бин будет создан. Автоконфигурационные классы активно используют аннотации, и в большинстве случаев конфигурация ничего делать и создавать не будет (см. выше «Условия и порядок регистрации бинов»).

Доступ к базе

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

Мы снова очень активно используем аннотации — в этот раз из Spring Data (точнее, JPA — это дремучая спецификация для доступа к данным). Этот класс описывает модель с двумя полями, одно из которых генерится автоматически. По этому классу будет автоматически создана модель данных (таблицы) в БД.

Теперь для этой модели пора создать репозиторий. Это еще проще, чем контроллер.

Все, репозиторий можно использовать для работы с базой — читать и писать записи. У внимательного читателя должен сработать WTF детектор — что здесь вообще происходит? Мы определяем интерфейс и внезапно он начинает работать с базой? Все так. Благодаря магии Spring Boot и Spring Data «под капотом» происходит следующее:

  • Увидев в зависимостях H2 (встраиваемая БД), Boot автоматически конфигурит (это ключевой компонент для подключения к базе) чтобы приложение работало с этой базой
  • Spring Data ищет всех наследников и автоматически генерит для них дефолтные реализации, которые включают базовые методы репозитория, типа , , etc.
  • Spring автоматически конфигурит слой для доступа к данным — JPA (точнее, его реализацию Hibernate)
  • Благодаря аннотации этот компонент становится доступным в нашем приложении (и мы его используем через пару минут)

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

Увидев в нашем конструкторе параметр типа , Spring найдет созданный Spring Data-ой репозиторий и передаст его в конструктор.

Теперь можно писать в базу в методе контроллера.

Практика для новичков

Одним из самих простых текстовых проектов на Java Spring является написание приложения «привет». Платформа не требует дополнительной регистрации или каких-либо сложных конструкций и форм на bootstrap. Используем простой html без динамики. И пускай основная форма имеет:

  • Поле для ввода текста «привет».
  • Клавишу «создать запись», при нажатии на которую наш текст будет отправляться на обработку и сохраняться в БД.
  • Список, который будет отображать ранее создание записи.

Больше нам ничего не нужно. Переходим к Java Spring. Практика:

  • Понятное дело, установите на свой компьютер Java.
  • Поставьте мавен.
  • Создайте проект Spring-boot.
  • Установите БД.
  • Распределите классы моделей. Лучше всего создайте какой-то один.
  • Реализуйте операцию с компонентами с помощью create-read-update-delete.
  • Создайте форму на jsp.
  • Привяжите свою форму к соответствующему контроллеру.

Преимущества Spring Framework

Считается, что Spring Framework реализует модель разработки, основанную на лучших стандартах индустрии, и делает её доступной во многих областях Java. Таким образом к достоинствам Spring можно отнести:

  1. Относительная легкость в изучении и применении фреймворка в разработке и поддержке приложения.
  2. Внедрение зависимостей (DI) и инверсия управления (IoC) позволяют писать независимые друг от друга компоненты, что дает преимущества в командной разработке, переносимости модулей и т.д..
  3. Spring IoC контейнер управляет жизненным циклом Spring Bean и настраивается наподобие JNDI lookup (поиска).
  4. Проект Spring содержит в себе множество подпроектов, которые затрагивают важные части создания софта, такие как веб сервисы, веб программирование, работа с базами данных, загрузка файлов, обработка ошибок и многое другое. Всё это настраивается в едином формате и упрощает поддержку приложения.

Резюме

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

Spring Boot

Теперь переходим к следующей части. Допустим, нам надо сконфигурить подключение к MySQL базе данных. Если мы хотим использовать Spring Data JPA с Hibernate в качестве провайдера, нам потребуется сконфигурировать несколько бинов — (основной класс JPA), для подключения непосредственно к базе через JDBC драйвер и т.п. Но с другой стороны, если мы это делаем каждый раз и, по сути, делаем одно и то же — почему бы это не автоматизировать? Скажем, если мы указали строку подключения к базе и добавили зависимость на MySQL драйвер — почему бы чему-то автоматически не создать все нужные бины для работы с MySQL? Именно это и делает Spring Boot. По сути, Spring Boot это просто набор классов конфигурации, которые создают нужные бины в контексте. Точно так же их можно создать руками, просто Boot это автоматизирует.

DI контейнер

Ключевой и фундаментальный механизм Spring. Внешне очень простой, но внутри он предоставляет очень много механизмов для тонкой настройки зависимостей. По сути, любое приложение Спринг — это набор бинов, связанных вместе через DI контейнер.

Очень часто при обсуждении Spring звучит аргумент, что его можно легко заменить на любой леговесный DI контейнер (Guice, например) и получить то же самое, но легче и проще

И здесь очень важно понять — ценность Spring DI не в самом факте его наличия, а в его фундаментальности. Все библиотеки в экосистеме Spring, по сути, просто регистрируют свои бины в этом контейнере (включая и сам Spring) — и через иньекцию зависимостей разработчики приложения смогут получить нужные компоненты

Простой пример: при использовании Spring Security OAuth если сконфигурить параметры OAuth в , то Spring Security предоставит бин который мы можем просто заинжектить в своем коде. И этот бин при обращении к внешнему API будет знать, куда и как пойти, чтобы получить OAuth токен, как его обновлять, в какое место нашего запроса его добавлять и т.п. Так вот ценность DI тут в том, что это просто механизм общения между нашим кодом и Spring Security. И простой заменой реализации DI на Guice не добиться, чтобы Spring Security тоже начал его использовать. А если в этом новом DI не будет интеграции со всеми библиотеками Spring-а, то и ценность его сильно падает.

Еще один очень важный момент, который многие упускают при обсуждении DI контейнера, это то, что использование инъекции зависимостей не подразумевает создания интерфейсов для каждого компонента. Это очень простая мысль, но я много раз видел, что из-за своей простоты она не всегда очевидна. Более того, создание интерфейса, если у него лишь одна реализация — считается плохой практикой. Т.е. классы вполне могут сами по себе быть объектами DI. Более того, отсутствие интерфейса даже не мешает их мокать в тестах, т.к. Mockito, например, вполне умеет мокать классы.

Что такое реактивность?

Реактивная система

reactive manifesto

  • Responsive. Данный принцип говорит нам о том, что разрабатываемая система должна отвечать быстро и за определенное заранее заданное время. Кроме того система должна быть достаточно гибкой для самодиагностики и починки.
    Что это значит на практикте? Традиционно при запросе некоторого сервиса мы идем в базу данных, вынимаем необходимый объем информации и отдаем ее пользователю. Здесь все хорошо, если наша система достаточно быстрая и база данных не очень большая. Но что, если время формирования ответа гораздно больше ожидаемого? Кроме того, у пользователя мог пропасть интернет на несколько миллисекунд. Тогда все усилия по выборке данных и формированию ответа пропадают. Вспомните gmail или facebook. Когда у вас плохой интернет, вы не получаете ошибку, а просто ждете результат больше обычного. Кроме того, этот пункт говорит нам о том, что ответы и запросы должны быть упорядочены и последовательны.
  • Resilient. Система остается в рабочем состоянии даже, если один из компонентов отказал. Другими словами, компоненты нашей системы должны быть досточно гибкими и изолированными друг от друга. Достигается это путем репликаций. Если, например, одна реплика PostgreSQL отказала, необходимо сделать так, чтобы всегда была доступна другая. Кроме того, наше приложение должно работать во множестве экземпляров.
  • Elastic. Данный принцип говорит о том, что система должна занимать оптимальное количество ресурсов в каждый промежуток времени. Если у нас высокая нагрузка, то необходимо увеличить количество экзепляров приложения. В случае малой нагрузки ресурсы свободных машин должны быть очищены. Типичный инструменты реализации данного принципа: Kubernetes.
  • Message Driven. Здесь начинается наиболее важный пункт для Java-разработчика. Именно этим вопросом должно озаботиться наше приложение. Общение между сервисами должно происходить через асинхронные сообщения. Это значит, что каждый элемент системы запрашивает информацию из другого элемента, но не ожидает получение результата сразу же. Вместо этого он продолжает выполняеть свои задачи. Это позволяет увеличить пользу от системных ресурсов и управлять более гибко возникающими ошибками. Обычно такой результат достигается через реактивное программирование.

Spring: начало

Если вы только решили начать знакомиться с программированием на «Джава спринг», рекомендуем начинать именно с Java ee Spring (фреймворк). Это один из простейших методов с открытым исходным кодом для данной платформы «Джава». Фреймворк создает последовательную конструкцию, которую можно без проблем применить к большинству задач, что были уже ранее описаны на основе Java. Простота и прозрачность фреймворка позволит вам самостоятельно увидеть ошибки в написании.

Как писать на spring в 2017

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

  • Контроллер – inversion of control. Обеспечивают корректную работоспособность, отвечают за конфигурацию элементов приложения и регулируют функциональный цикл объектов Java.
  • Доступ к данным – функционал направлен на управление реляционными базами данных (БД) в Java. Благодаря данному фреймворку обеспечивается решение огромного количества сложных задач на базе Java environments.
  • Фреймворк аспектно-ориентировочной настройки. Работает с компонентами, которые не могут реализоваться без каких-либо потерь на Java.
  • Управления транзакциями. Фреймворк координирует АР и инструментарий настроившими объектами управлениями транзакций для элементов Java.
  • Фреймворк удаленного доступа и управления. Конфигурация происходит локально.
  • Аутентификация и авторизация. Поддерживают конфигурацию на многих популярных протоколах через Spring Security.

На сегодняшний день для всех фреймворков в «Спринг» предоставляется ряд возможностей:

  • Автоматическое управление ресурсами.
  • Обработка исключенных компонентов при доступе к данным исключения самого «Спринга».
  • Прозрачное управление транзакциями во время каких-либо операций с данными.
  • Разархивирование ресурсов.
  • Обработка абстракции во многих форматах.

Необходимо понимать предназначение всех фреймворков, так как это основа Java Spring. Для начинающих рекомендуется начинать изучать все компоненты по группам и пробовать их использовать на примерах.

Actuator

Spring Boot Actuator это мощный инструмент диагностики работающего приложения, который умеет давать много полезной аналитики (более того, набор этих метрик можно легко расширять из приложения).

После добавления Actuator к проекту, Spring Boot опубликует список доступных бинов через URL . Этот список так же доступен через JMX (Java Management Extensions), и последняя версия Intellij IDEA умеет показывать все бины приложения прямо из окна запуска.

Резюме

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

Надеюсь, что эта статья помогла понять важность и ценность Spring именно как экосистемы и убрала немного «магичности» в происходящем, особенно при использовании Spring Boot. Мой совет — не бойтесь углубляться в недра фреймворка, читайте исходники и документацию, благо они у Spring-a почти эталонные, на мой взгляд

Так же стоит отметить, что в готовящемся к выходу в сентябре Spring 5 появится несколько новых концепций, направленных на создание простых приложений, и понижение уровня «магии» (хотя, как мы выяснили, магии там особо и нет). Одна из концепций это Functional Bean Registration, которая позволяет регистрировать бины в контексте с помощью функций, или даже с помощью неплохого DSL на Kotlin (а Spring 5 добавит много хорошего для поддержки Kotlin). Следующая, но еще более важная вещь, это комбинация Functional Web Framework и WebFlux (reactive web framework), которая позволит создавать веб-приложения вообще без зависимости на Spring MVC и запускать их без сервлет контейнеров. Приложение вполне сможет работать без контекста приложений и DI, и описываться просто как набор функций . Об этом можно чуть больше почитать здесь (на английском).

DI/IoC

IoC (Inversion of Control) — инверсия управления. При использовании библиотеки вы сами прописываете в своем коде какой метод какого объекта вызвать, а в случает с фреймворками — чаще всего уже фреймворк будет вызывать в нужный ему момент тот код, который уже написали. То есть, тут уже не вы управляете процессом выполнения кода/программы, а фреймворк это делает за вас. Вы передали ему управление (инверсия управления).

Под DI(Dependency Injection) — внедрение зависимостей, это встраивание различных объектов в определённые классы.

public interface Music {

   void setSong(String songName);

   String getSong();

}

public class MusicPlayer {

   private Music music;       /*-----Слабая зависимость, так как реализовано через интерфейс.-----*/

   public MusicPlayer(Music music) {     /*-----Внедрение слабой зависимости посредством конструктора-----*/
     this.music = music;
   }

   public void playMusic() {
     System.out.println("Playing: " + music.getSong());
   }

}

Расшифровка основных аббревиатур в Java Spring

Знакомясь с таким специфичным скриптовым методом программирования, как «Джава спринг», можно встретить разные аббревиатуры. Как правило, не на всех сайтах или в учебниках можно найти их расшифровку, поэтому давайте разберемся, что есть Java Spring. Пример:

  • Inversion of Control – IoC – инверсия контроля или, проще говоря, главный модуль приложения.
  • АОП – аспектно-ориентировочное программирование. Благодаря этому модулю «Джава» может без проблем подключиться к любой точке доступа и прописать там необходимый код.
  • MVC — Model-view-controller – это структурированный шаблон, который задает и описывает способ построения конструкции всего приложения, обеспечивает взаимодействие всех частей в одной системе. Создает объекты web.
  • Класс WEB предназначит для того, чтобы облегчить разработку авторизации фреймворка, отвечает за доступ к бинам и т. д.
  • ORM- Object-Relational Mapping – связывает БД (базы данных) с концепциями объекто-ориентировочных методов программирования, создавая новую виртуальную базу данных.
  • DAO предназначен для работы с базами данных в структуре «Спринга».
  • Service Abstraction – задает интерфейсы (внешней вид) приложения, то есть отвечает за абстрагирование задачи.

Сегодня можно найти достаточно много полезной и интересной информации по Java Spring. Уроки, учебники, веб-семинары непременно помогут вам без проблем изучить данный скриптовый язык программирования. Если у вас возникли какие-либо проблемы с написанием приложения, пересмотрите документацию по «Спрингу», в которой авторы достаточно детально описали все требования к структуре «Джава», а также ответили на вопросы, как исправить часто совершаемые ошибки.

Java Hibernate

Практически все веб-приложения не могут обойтись без хранения большого количества информации. Как правило, для решения этой проблемы используют различные специальные программы – СУБД и т. д. По структуре организации и частоте использования базы данных можно поделить на несколько подгрупп, и так получилось, что реляционные являются наиболее распространенными. Как правило, описание данных конструкций достаточно большие, и не всегда их рационально использовать.

Java Spring — технология для облегчения написания приложения — рекомендует использовать ORM (Object-Relational Mapping). Реализует данный метод библиотека Hibernate, которая преображает данные из одного вида в другой. Кроме того, с ее помощью можно легко настроить подключения к файлам СУБД и управлять транзакциями.

Для преображення одного класса в другой на Java Hibernate Spring существует несколько специальных генераторов:

  • Increment.
  • Identity.
  • Sequence.
  • Hilo.
  • Seqhilo.
  • Uuid.
  • Guid.
  • Native.
  • Assigned.
  • Foreign.
  • sequence-identity.

Преимущества использования Java Hibernate Spring:

  • Простая структура механизмов взаимосвязи с БД и POJO.
  • Автоматическая генерация компонентов Primary Key.
  • HQL.
  • Кэш: Second level, Session Level и, конечно же, Query.
  • Хорошая производительность.
  • Выборка Outer Join.

Как писать на spring в 2017

Клиентский код

Оставим за рамками этой статьи, пример можно увидеть в исходном коде. Цель этого кода — исключительно продемонстрировать как получить JSON данные с сервера, интеграции с клиентскими фреймворками React, Angular etc намеренно оставлены вне рамок этой статьи.

Тестирование

Spring так же предоставляет мощные средства для Integration и Unit тестирования приложения. Пример кода, который проверяет контроллер:

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

Аналогично для API тестов есть набор хелперов для проверки JsonPath выражений.

Тестирование в Spring это все таки отдельная тема, поэтому мы не будем сильно на этом останавливаться сейчас.

Деплоймент

Чтобы собрать и запустить наше приложение в продакшене есть несколько вариантов.

  1. Задеплоить полученный JAR (или даже WAR) в сервлет контейнер, например Tomcat. Это не самый простой путь, его нужно выбирать только если у вас уже есть работающий сервлет контейнер или сервер приложений.
  2. Использовать магию Spring Boot. JAR файл, собранный используя плагин Spring Boot (который автоматически добавляется в проекты созданные через Spring Initializr), является полностью самодостаточным.

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

Для деплоймента этого JAR файла не нужно ничего, кроме установленной Java (JRE). Это так называемый fat JAR — он включает в себя и встроенный сервлет контейнер (Tomcat по умолчанию) и фреймворк, и все библиотеки-зависимости. По сути, он является единственным артефактом деплоймтента — его можно просто копировать на целевой сервер и запускать там.

Более того, файл можно сделать «выполняемым» и запускать его просто из командной строки (Java, конечно, все равно необходима).

На базе этого файла можно легко создать Docker образ или установить его как демон. Больше деталей доступно в официальной документации.

Заключение

Получилось, все же, очень сжато — но уложить даже самый простой вводный курс по Spring в рамки одной статьи не очень просто. Надеюсь, это поможет кому-то сделать первый шаги в Spring-е, и хотя понять его фундаментальные концепции.

Как вы успели заметить, в тексте статьи много раз звучало слово «магия Spring». По сути своей, это очень «магический» фреймворк — даже взглянув на самую верхушку айсберга мы уже видели, что Spring много всего делает в фоне. Это является и плюсом, и минусом фреймворка. Плюс несомненно в том, что многие сложные вещи (очень многие) можно сделать одной аннотацией или зависимостью. Минус же это скрытая сложность — чтобы решить какие-то сложные проблемы, заставить фреймворк работать в крайних случаях или понимать все тонкости и аспекты нужно его неплохо знать.

Чтобы сделать этап «знать» как можно проще, Spring обладает отличной документацией, огромным сообществом, и чистыми исходниками, которые вполне можно читать. Если расположить Spring на шкале Рича Хики, он (Spring) несомненно попадет в easy, но уж точно не simple. Но для современного энтерпрайза (и не только энтерпрайза) он дает невероятные возможности чтобы получить production-ready приложение очень быстро и концентрироваться на логике приложения, а не инфраструктуры вокруг.

Ссылки

  • Исходный код на github
  • Главный сайт Spring с кучей разных гайдов spring.io
  • Официальная документация Spring Framework

Scope у Spring Bean

В Spring предусмотрены различные области времени действия бинов:

singleton — может быть создан только один экземпляр бина. Этот тип используется спрингом по умолчанию, если не указано другое

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

Создается новый экземпляр при каждом HTTP request.
session — новый бин создается в контейнере при каждой новой HTTPS (HyperText Transfer Protocol Secure) сессии.
global-session: используется для создания глобальных бинов на уровне сессии для Portlet приложений.

Конфигурация

Итак, если приложение — это набор бинов, чтобы оно заработало нам нужно этот набор описать.

Конфигурация — это просто описание доступных бинов. Spring дает несколько вариантов, как можно описать набор бинов, которые сформируют приложение. Исторический вариант — это через набор xml файлов. В наши дни ему на смену пришли Java аннотации. Spring Boot построен на аннтациях чуть более, чем полностью и большинство современных библиотек в принципе тоже можно сконфигурить через аннотации. В третьем своем поколении, конфигурация бинов пришла к подходу функциональной регистрации (functional bean registration), которая станет одной из важных новых фич готовящегося к выходу Spring 5.

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

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

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

admin
Оцените автора
( Пока оценок нет )
Добавить комментарий