Когда мы думаем о сообществе разработчиков на языке Java, мы вспоминаем полчища старателей, которые в конце 1840-х годов неистово прочесывали реки Северной Америки в поисках золотых самородков. Наши "реки" - реки Jаvа-разработчиков - изобилуют проектами с открытым кодом, но, в отличие от истории со старателями, нахождение действительно полезного проекта может оказаться длительным по времени и трудным процессом.
Многим проектам с открытым кодом Java характерна общая особенность - они были призваны просто заполнить пробел в реализации последней "модной" технологии или шаблона. С учетом сказанного, многие высококачественные и полезные проекты предназначены для решения реальных потребностей в реальных приложениях. С одним из них вы ознакомитесь достаточно подробно - и это, как не трудно догадаться, Spring.
На протяжении всего моего блога вы будете сталкиваться со многими применениями разнообразных технологий с открытым кодом, причем все они объединены в платформу Spring Framework. Благодаря Spring, разработчик приложений может пользоваться широким спектром инструментов с открытым кодом, не занимаясь написанием больших объемов кода и не привязывая создаваемое приложение слишком тесно к какому-то конкретному инструменту.
В этой статье вы ознакомитесь с платформой Spring Framework без анализа крупных примеров или изучения подробных объяснений.
Что такое Spring?
Пожалуй, наиболее трудной частью объяснения технологии Spring является точная классификация того, что она собой представляет. Обычно Spnng описывают как облегченную платформу для построения Jаvа-приложений, но с этим утверждением связаны два интересных момента.
Во-первых, Spring можно применять для построения любого приложения на языке Java (например, автономных, веб-приложений или приложений Java Enterprise Edition (JEE)) в отличие от многих других платформ (таких как Apache Struts, которая ограничена созданием только веб-приложений).
Во-вторых, характеристика облегченная в действительности не имеет никакого отношения к количеству классов или размеру дистрибутива, а вместо этого определяет принцип всей философии Spring — минимальное воздействие. Платформа Spring является облегченной в том смысле, что для использования всех преимуществ ядра
Spring вы должны вносить минимальные (если вообще какие-либо) изменения в код своего приложения, а если в какой-то момент вы решите прекратить пользоваться Spring, то и это сделать очень просто.
Обратите внимание, что речь идет только о ядре Spring - многие дополнительные компоненты Spring, такие как доступ к данным, требуют более тесной привязки к Spring Framework. Однако польза от такой привязки вполне очевидна.
Эволюция Spring Framework
Платформа Spring Framework берет начало из книги Рода Джонсона Experl One-on-One: J2EE Design and Development (Wox, 2002 г.). За прошедшее десятилетие Spring Framework значительно выросла в плане основной функциональности, связанных проектов и поддержки со стороны сообщества. Теперь, когда доступен новый крупный выпуск Spring Framework, полезно взглянуть на важные средства, которые появились в каждом промежуточном выпуске Spring, в конечном итоге приведя к выходу Spring Framework 4.0.
- Spring 0.9
- Первый публичный выпуск платформы, основанный на книге Expert One-on-One: J2EE Design and Development
- Spring 1.x
- Spring Core: контейнер бинов и поддерживающие утилиты
- Spring Context: ApplicationContext, пользовательский интерфейс, проверка достоверности, JNOI, Enterprise JavaBeans (EJB), удаленная обработка и почтовая поддержка
- Spring DAO: поддержка инфраструктуры транзакций, Java Oatabase Connectivity (JOBC) и объектов доступа к данным (data access object — DАО)
- Spring ORM: поддержка Hibemate, iBATJS и Java Data Objects (JDO)
- Spring АОР: реализация аспектно-ориентированного программирования (АОП), согласованного с альянсом АОР Alliance
- Spring Web: базовые средства интеграции, такие как функциональность множественного содержимого, инициализация контекста посредством прослушивателей сервлетов и контекст неб-ориентированных приложений
- Spring Web MVC: инфраструктура "модель-представление-контроллер" (Model-View-Controller — MVC) для построения веб-приложений
- Spring 2.х
- Более простое конфигурирование XML за счет применения новой конфигурации, основанной на схеме XML (XML Schema), а не на формате ОТО. Заметные области, подверженные усовершенствованиям, включают определения бинов, АОП и декларативные транзакции
- Новые области действия бинов для использования в веб-приложениях и порталах (на уровне запроса, сеанса и глобального сеанса)
- Поддержка аннотаций
@AspectJдля разработки с применением АОП о Уровень абстракции Java Persistence API (JPA) - Полная поддержка асинхронных объектов POJO (Plain Old Java Object - простой старый объект Java), управляемых сообщениями JMS
- Упрощения JDBC, в том числе SimpleJdbcTemplate, когда применяется Java 5+
- Поддержка именованных параметров JDBC (NamedParameterJdbc Template)
- Библиотека дескрипторов форм для Spring MVC
- Введение инфраструктуры Portlet MVC
- Поддержка динамических языков: бины могут быть написаны на JRuby, Groovy и BeanShell
- Поддержка уведомлений и управляемой регистрации MBean в JMX
- Абстракция TaskExecutor, введенная для планирования задач
- Поддержка аннотаций Java 5, в частности для
@Transactionalи@Requiredв дополнение к@AspectJ - Spring 2.5.х
- Новые конфигурационные аннотации
@Autowiredи поддержка аннотаций JSR-250(@Resource,@PostConstruct,@PreDestroy) - Новые стереотипные аннотации:
@Component,@Repository,@Service,@Controller - Поддержка автоматического сканирования путей классов для автоматического обнаружения и связывания классов, снабженных стереотипными аннотациями
- Обновления АОП: появление элемента среза (pointcut) вида bean ( ... ) и привязывания во время загрузки (load-time weaving) AspectJ
- Полная поддержка управления транзакциями WebSphere
- В дополнение к аннотации
@Controllerиз Spring MVC добавлены аннотации@RequestMapping,@RequestParamи@ModelAttributeдля поддержки обработки запросов посредством конфигурации с помощью аннотаций - Поддержка Ties 2
- Поддержка JSF 1.2
- Поддержка JAX-WS 2.0/2.1
- Введение инфраструктуры Spring TestContext Framework, которая поддерживает управляемое аннотациями тестирование взаимодействия, не зависящее от применяемой инфраструктуры тестирования
- Возможность развертывания контекста приложения Spring как адаптера JCA
- Spring 3.0.x
- Поддержка средств Java 5 — обобщений, аргументов переменной длины и других усовершенствований
- Пероклассная поддержка адаптеровCallables, Futures, ExecutorService, а также интеграция ThreadFactory
- Модули платформы теперь управляются отдельно, с одним деревом исходного кода на модуль JAR
- Введение языка выражений Spring (Spring Expression Language — SpEL) о Интеграция основных средств и аннотаций Java Config
- Универсальная система преобразования типов и система форматирования полей
- Всеобъемлющая поддержка REST
- Новое пространство имен MVC XML и дополнительные аннотации наподобие
@CookieValueи@RequestHeadersдля Spring MVC - Улучшения проверки достоверности и поддержка JSR-303 ("Проверка достоверности бинов")
- Начальная поддержка для Java ЕЕ 6: аннотация
@Async/@Asynchronous, JSR-303, JSF 2.0, JPA 2.0 и т.д. - Поддержка встроенных баз данных, таких как HSQL, Н2 и DeAy
- Spring 3.1.х
- Новая абстракция Cache
- Профили определения бинов могут определяться в XML; кроме того, имеется поддержка аннотации @Profile
- Абстракция среды для унифицированного управления свойствами
- Эквиваленты в форме аннотаций для распространенных элементов пространства имен Spring XML, такие как @CornponentScan,
@EnableTransactionManagernent,@EnableCaching,@EnableWebMvc,@EnableScheduling,@EnableAsync,@EnableAspectJAutoProxy,@EnableLoadTirneWeavingи@EnableSpringConfigured - Поддержка Hibernate 4
- Поддержка инфраструктурой Spring TestContext Framework классов
@Configurationи профилей определения бинов - Пространство имен с: для упрощенного внедрения через конструктор о Поддержка конфигурации на основе кода Servlet 3 контейнера типа сервлета
- Возможность начальной загрузки EntityManagerFactory интерфейса JPA без
persistence.xrnl - Добавление в Spring MVC средств Flash и RedirectAttributes, которые позволяют атрибутам продолжать существование после перенаправления за счет использования сеанса НТТР
- Усовершенствования переменных шаблонов URI
- Возможность снабжать аннотацией
@Validаргументы методов контроллеров@RequestBodyв Spring MVC - Возможность снабжать аннотацией
@RequestPartаргументы методов контроллеров в Spring MVC - Spring 3.2.х
- Поддержка асинхронной обработки запросов на основе Servlet 3 о Новая инфраструктура тестирования Spring MVC
- Новые аннотации
@ControllerAdviceи@MatrixVariableв Spring MVC - Поддержка обобщенных типов в RestTemplate и в аргументах
@RequestBody - Поддержка Jackson JSON 2
- Поддержка Тiles 3
- Аргумент
@RequestBodyили@RequestPartтеперь может сопровождаться аргументом Errors, делая возможной обработку ошибок проверки достоверности - Возможность исключения шаблонов URL за счет применения пространства имен MVC и параметров конфигурации Java Config
- Поддержка
@DateTimeFormatбез Jodame - Глобальное форматирование даты и времени
- Усовершенствования параллелизма во всей платформе, сводящие к минимуму блокировки и в целом улучшающие параллельное создание ограниченных/прототипированных бинов
- Новая система сборки, основанная на Gradle
- Переход на GitHub: https://github.com/SpringSource/spring-framework
- Усовершенствованная поддержка Java SE 7 / OpenJDK 7 внутри платформы и сторонних зависимостей. Теперь CGL^ и ASM являются частью Spring. В дополнение к AspectJ 1.6 поддерживается версия AspectJ 1.7
- Spring 4.0
- Улучшенная практика начала работы посредством набора руководств Getting Started на веб-сайте www.spring.io/guides
- Удаление устаревших пакетов и методов, относящихся к предыдущей версии Spring 3
- Поддержка Java 8 с поднятием минимальной версии до Java 6 Update 18
- Базовым уровнем для Spring Framework 4.0 теперь считается версия Java ЕЕ 6 и выше
- Язык, специфичный для предметной области (domain-specific language - DSL), с помощью которого определяются бины Groovy, позволяет их конфигурировать посредством синтаксиса Groovy
- Усовершенствования, касающиеся основных контейнеров, тестирования и общей разработки веб-приложений
- Обмен сообщениями WebSocket, SockJS и STOMР
- Spring 5.0
- Поддержка Java 9. Как и следовало ожидать, новый Spring вполне комфортно себя чувствует, работая на новой версии Java. Это означает, что новая версия Spring будет работать как включенная в classpath, так и в module path (используя automatic modules). Сборка и все тесты самого фреймворка работают на новой JDK9 (хотя по умолчанию все еще используют JDK8).
- Реактивность. Новая версия фреймворка добавляет новый проект в копилку Spring — Spring Reactive Web Framework или WebFlux. Это полностью асихронный и неблокирующий веб-фреймоворк предназначенный для работы поверх event loop, как альтернативу традиционным сервлетам работающих поверх классического пула потоков.
- Поддержка Kotlin. Kotlin теперь не только официально поддерживаемый Google язык для разработки на Andriod, но и официально поддерживаемый Spring-ом язык для backend разработки.
- Новая документация. Официальная документация была реструктурирована и разбита на небольшие модули, сгруппированные по функциональности.
Инверсия управления или внедрение зависимостей?
Ядро Spring Framework основано на принципе инверсии управления (lnversion of Control - IoC), когда создание и управление зависимостями между компонентами становятся внешними. Рассмотрим пример, в котором класс Foo при выполнении обработки определенного вида зависит от экземпляра класса Bar. Традиционно Foo создает экземпляр Bar, используя операцию new или получая нужный экземпляр от какой-то разновидности фабричного класса. Согласно подходу JoC, экземпляр класса Ва r (или его подкласса) предоставляется классу Foo во время выполнения некоторым внешним процессом. Такое поведение, т.е. внедрение зависимостей во время выполнения, приводящее к инверсии управления, было переименовано Мартином Фаулером в более описательное - внедрение зависимостей (Dependency lnjection - DI).
На заметку! Применение термина внедрение зависимостей при ссылке на инверсию управления всегда корректно. В контексте Spring эти термины можно использовать взаимозаменяемо, совершенно не теряя при этом смысла.
Реализация DI в Spring основана на двух ключевых концепциях Java - компонентах JavaBean и интерфейсах. При использовании Spring в качестве поставщика DI вы получаете гибкость определения конфигурации зависимостей внутри своих приложений разнообразными путями (например, ХМL-файлы, конфигурационные классы Java, аннотации в коде или новый метод определения бинов Groovy). Компоненты JavaBean (POJO) предоставляют стандартный механизм для создания ресурсов Java, которые поддаются конфигурированию многими способами вроде конструкторов и методов установки. Spring использует спецификацию JavaBean для формирования ядра своей модели конфигурации DI; в действительности любой ресурс, управляемый Spring, называется бином (bean).
Интерфейсы и DI - это взаимовыгодные технологии. Очевидно, что проектирование и написание кода интерфейсов предназначено для гибких приложений, но сложность связывания вместе приложения, использующего интерфейсы, довольно высока и требует от разработчиков дополнительных усилий по кодированию. За счет применения DI объем кода, который необходим при проектировании приложения на основе интерфейсов, снижается почти до нуля. Кроме того, с помощью интерфейсов можно получить максимальную отдачу от DI, потому что бины могут использовать любую реализацию интерфейса для удовлетворения, их зависимости. Применение интерфейсов также позволяет Spring задействовать динамические прокси JDK (шаблон Proxy), чтобы предоставить мощные концепции вроде АОП для сквозной функциональности.
В контексте внедрения зависимостей Spring действует больше подобно контейнеру, чем платформе, предоставляя экземпляры классов вашего приложения со всеми необходимыми зависимостями, но делает это гораздо менее навязчивым способом. Использование Spring для DI основано всего лишь на следовании внутри своих классов соглашениям об именовании, принятым для компонентов JavaBean; ни специальных классов, предназначенных для наследования, ни собственных схем именования, которые должны соблюдаться, не предусмотрено. Во всяком случае, единственным изменением, которое делается в приложении, применяющем DI, является открытие доступа к дополнительным свойствам ваших компонентов JavaBean, что позволяет внедрять больше зависимостей во время выполнения.
Эволюция внедрения зависимостей
Благодаря распространению Spring и других платформ DI, за последние несколько лет технология внедрения зависимостей обрела широкое признание в сообществе разработчиков на языке Java. В то же время разработчики были уверены, что использование DI было наилучшей практикой в разработке приложений, и преимущества применения DI были также хорошо изучены.
Популярность DI также была подтверждена официальным принятием процессом сообщества Java (Java Community Process - JCP) документ JSR-330 ("Dependency Injection for Java" - "Внедрение зависимостей для Java") в 2009 году. Документ JSR-330 стал формальным запросом спецификации Java (Java Specification Request - JSR) и одним из ее лидирующих авторов был Род Джонсон, основатель Spring Framework.
В JEE 6 документ JSR-330 стал одной из спецификаций, входящих в полный комплект технологий. За это время архитектура EJB (начиная с версии 3.0) также была существенно модернизирована; с целью упрощения разработки разнообразных приложений Enterprise JavaBeans была принята модель DI.
Полезно взглянуть на преимущества, которые обеспечивает использование DI по сравнению с более традиционным подходом.
- Сокращение объема связующего кода. Одним из самых больших плюсов Dl является возможность значительного сокращения объема кода, который должен быть написан для связывания вместе компонентов приложения. Часто этот код тривиален, так что создание зависимости сводится просто к созданию нового экземпляра объекта. Тем не менее, связующий код может стать довольно сложным, когда нужно искать зависимости в репозитории JNDI или если зависимости не могут вызываться напрямую, как в случае с удаленными (дистанционно) ресурсами. В таких ситуациях DI может действительно упростить связующий код, предоставляя автоматический поиск в JNDI и автоматическое создание прокси для удаленных ресурсов.
- Упрощенная конфигурация приложения. За счет применения DI процесс конфигурирования приложения значительно упрощается. Для конфигурирования классов, которые могут быть внедрены в другие классы, можно использовать разнообразные варианты. Тот же самый подход можно применять для формулирования требований зависимостей для внедряющего объекта при внедрении соответствующего экземпляра бина или свойства. Вдобавок 01 намного упрощает обмен одной реализации зависимости с другой. Рассмотрим случай, когда есть компонент DAO, который выполняет операции над данными в базе данных PostgreSQL, и его нужно обновить до Oracle. С помощью DI соответствующую зависимость бизнес-объектов можно легко переконфигурировать, чтобы она использовала реализацию Oracle вместо PostgreSQL.
- Возможность управления общими зависимостями в единственном репозитории.
- При традиционном подходе к управлению зависимостями общих служб, таких как подключение к источнику данных, транзакция и удаленные службы, вы создаете экземпляры (или получаете их из определенных фабричных классов) зависимостей там, где они нужны (внутри зависимого класса). Это приводит к распространению зависимостей по множеству классов в приложении, что может затруднить их изменение. В случае использования DI вся информация об общих зависимостях содержится в единственном репозитории, существенно упрощая управление зависимостями и уменьшая подверженность ошибкам.
- Улучшенная возможность тестирования. Когда классы проектируются для DI, становится возможной простая замена зависимостей. Это особенно полезно при тестировании приложения. Рассмотрим бизнес-объект, который производит определенную сложную обработку; в рамках этого он использует DAO для доступа к данным, хранящимся в реляционной базе данных. При тестировании вас не интересует проверка DAO - вам нужно протестировать бизнес-объект с разнообразными наборами данных. При традиционном подходе, когда бизнес-объект самостоятельно отвечает за получение экземпляра DAO, тестирование довольно затруднительно, поскольку нет возможности заменить реализацию DAO имитированной реализацией, которая возвращала бы наборы тестовых данных. Вместо этого нужно будет удостовериться, что тестовая база данных содержит корректные данные, и применять для прогона тестов полную реализацию DAO. В случае использования DI можно создать имитированную реализацию объекта DAO, которая возвращает наборы тестовых данных, и затем передавать их бизнес-объекту с целью проверки. Этот механизм может быть расширен для тестирования любого уровня приложения и особенно полезен при тестировании веб-компонентов, для которых создаются имитированные реализации
HttpServletRequestиHttpServletResponse. - Стимулирование качественных проектных решений для приложений. Вообще говоря, проектирование для Dl означает проектирование с использованием интерфейсов. Типовое приложение, ориентированное на внедрение зависимостей, построено так, что все основные компоненты определяются как интерфейсы, после чего создаются конкретные реализации этих интерфейсов и затем связываются вместе с применением контейнера 01. Такая разновидность проектного решения была возможна в Java еще до появления DI и основанных на Dl контейнеров, подобных Spring. Но за счет использования Spring вы получаете в свое распоряжение целый ряд средств DI и можете сосредоточиться на построении логики приложения, а не на поддерживающей DI платформе.
Как видите, технология DI предоставляет немало преимуществ приложению, однако она отнюдь не лишена недостатков. В частности, DI может затруднить вы яснение, какая реализация конкретной зависимости к каким объектам привязана, для тех, кто не особенно хорошо ориентируется в коде. Как правило, эта проблема возникает только при отсутствии опыта работы с DI. С обретением опыта и следуя рекомендациям по программированию для DI (например, помещение всех встраиваемых классов на каждом уровне приложения в один и тот же пакет), разработчики будут способны легко получить представление о картине в целом. Преимущества почти всегда перевешивают этот небольшой недостаток, тем не менее, о нем следует помнить при планировании приложения.
За пределами внедрения зависимостей
Само по себе ядро Spring со своими развитыми возможностями DI является вполне достойным инструментом, но чем Spring действительно выделяется - так это широчайшим набором дополнительных средств, которые все элегантно спроектированы и построены с использованием принципов DI. Платформа Spring предлагает средства для всех уровней приложения, от вспомогательных API-интерфейсов для доступа к данным до расширенных возможностей MVC. Упомянутые возможности Spring хороши тем, что хотя Spring часто предоставляет собственный подход, они легко интегрируются с другими инструментами Spring, становясь полноправными членами семейства Spring.
Поддержка Java 8
Версия Java 8 привносит множество захватывающих возможностей, поддерживаемых в Spring Framework 4, наиболее примечательными из которых являются лямбда-выражения и ссылки на методы с интерфейсами обратного вызова Spring. Другая функциональность Java 8 включает первоклассную поддержку j ava. time (JSR-310) и обнаружение имен параметров. Несмотря на то что Spring Framework 4.0 поддерживает Java 8, по-прежнему обеспечивается обратная совместимость с JDK 6 Update 18. При разработке новых проектов рекомендуется применять самую последнюю версию Java, такую как 7 или 8.
Аспектно-ориентированное программирование с использованием Spring
Аспектно-ориентированное программирование (АОП) предоставляет возможность реализации сквозной логики, т.е. логики, которая применяется к множеству частей приложения, в одном месте и обеспечивает ее автоматическое применение по всему приложению.
Подход Spring к АОП заключается в создании Динамических прокси для целевых объектов и привязывании объектов к сконфигурированному совету для выполнения сквозной логики. Согласно природе динамических прокси JDK, целевые объекты должны реализовывать интерфейс, объявляющий метод, в котором будет применен совет АОП.
Еще одной популярной библиотекой АОП является проект Eclipse AspectJ (www.eclipse.org/aspectj), который предоставляет более мощные средства, включая конструирование объектов, загрузку классов и большую возможность выделения сквозной функциональности.
Хорошая новость для разработчиков, применяющих Spring и АОП, заключается в том, что начиная с версии 2.0, в Spring поддерживается более тесная интеграция с AspectJ.
Ниже перечислено несколько особенностей.
- Поддержка выражений со срезами в стиле AspectJ.
- Поддержка стиля аннотаций
@AspectJпри использовании для привязывания АОП из Spring. - Поддержка аспектов, реализованных в AspectJ для 01.
- Поддержка привязывания во время загрузки внутри pplicationContext в Spring.
На заметку! Начиная с версии Spring Framework 3.2, поддержка аннотации
@AspectJможет быть включена с помощью Java Config.
Оба вида АОП имеют свои области применения, и в большинстве случаев АОП из Spring достаточно для удовлетворения требований сквозной функциональности в приложении. Однако при наличии более сложных требований может использоваться AspectJ, причем в одном приложении Spring можно смешивать оба вида АОП.
АОП имеет много применений. Типичное применение, демонстрируемое во множестве традиционных примеров АОП, связано с выполнением некоторого вида регистрации, но возможности АОП выходят далеко за рамки тривиальных приложений регистрации. На самом деле внутри самой платформы Spring Framework АОП используется для многих целей, в частности, при управлении транзакциями.
Язык выражений Spring (SpEL)
Язык выражений (Expression Language - EL) - это технология, позволяющая приложению манипулировать объектами Java во время выполнения. Однако с EL связана одна проблема: разные технологии предлагают собственные реализации и синтаксис EL. Например, Java Server Pages (JSP) и Java Server Faces (JSF) имеют собственные языки EL, синтаксис которых отличается друг от друга. Для решения этой проблемы и был создан унифицированный язык выражений (Unified Expression Language).
Поскольку платформа Spring Framework развивалась слишком быстро, существовала потребность в стандартном языке выражений, который мог бы совместно использоваться всеми модулями Spring Framework, а также другими проектами Spring. Поэтому, начиная с версии 3.0, в Spring появился язык выражений Spring (Spring Expression Language - SpEL), который предоставляет мощные средства для вычисления выражений, а также для доступа к объектам Java и бинам Spring во время выполнения. Результаты вычислений могут применяться в приложении или внедряться в другие компоненты JavaBean.
Проверка достоверности в Spring
Проверка Достоверности - еще одна обширная тема в приложениях любого вида. В идеальном сценарии правила проверки достоверности для атрибутов внутри компонентов JavaBean, содержащих данные, могуг быть применены согласованным образом вне зависимости от того, где инициирован запрос на манипуляцию данными - в пользовательском интерфейсе, пакетном задании или же удаленно (например, веб-службой, веб-службой REST или удаленным вызовом процедуры (Remote Procedure Catl - RPC)).
Для решения указанных проблем в Spring предлагается встроенный АРL- интерфейс проверки достоверности в виде интерфейса Validator. Этот интерфейс предоставляет простой и лаконичный механизм, который позволяет инкапсулировать логику проверки достоверности в класс, ответственный за проверку достоверности целевого объекта. В дополнение к целевому объекту метод проверки достоверности принимает объект Errors, который используется для сбора любых возникающих ошибок при проверке.
В Spring также имеется полезный служебный класс ValidationUtils, который предлагает удобные методы для вызова других валидаторов, проверки наличия распространенных проблем вроде пустых строк и сообщения об ошибках указанному объекту Errors.
Руководствуясь необходимостью, JCP была также разработана спецификация Bean Validation API (JSR-303), которая предоставляет стандартный путь определения правил проверки достоверности для бинов. Например, когда к свойству бина применяется аннотация @NotNull, она указывает, что атрибут не должен содержать нулевое значение перед тем, как он может быть сохранен в базе данных.
Начиная с версии 3.0, в Spring доступна встроенная поддержка спецификации JSR-303. Для использования этого API-интерфейса нужно просто объявить объект LocalValidatorFactoryBean и внедрить интерфейс Validator в любые бины, управляемые Spring. Платформа Spring найдет лежащую в основе реализацию. По умолчанию Spring сначала ищет Hibemate Validator (hibernate. org /subproj ects/ validator), который представляет собой популярную реализацию JSR-303. Многие технологии пользовательских интерфейсов (например, JSF 2 и Google Web Toolkit), включая Spring MVC, также поддерживают применение проверки достоверности JSR-303 в пользовательском интерфейсе. Прошли те времена, когда разработчикам приходилось писать одну и ту же логику проверки достоверности как в пользовательском интерфейсе, так и на уровне взаимодействия с базой данных.
На заметку! Начиная с версии Spring Framework 4.0, померживается версия 1.1 спецификации Bean Validation API (JSR-349).
Доступ к данным в Spring
Доступ к данным и постоянство являются, пожалуй, наиболее обсуждаемыми темами в мире Java. Платформа Spring обеспечивает великолепную интеграцию с любым выбранным инструментом доступа к данным. Вдобавок для многих проектов Spring предлагает в качестве жизнеспособного решения простое средство JDBC (Java Database Connectivity - подключение к базам данных Java) с его упрощенными API-интерфейсами, представляющими собой оболочки для стандартного API- интерфейса.
На заметку! Начиная с версии Spring Framework 4.0, поддержка iBATIS была удалена. Проект MyBatis-Spring предлагает интеграцию с платформой Spring; дополнительные сведения о нем можно получить по адресу http://mybatis.github.io/spring/.
Однако по причине безудержного роста Интернета и облачных вычислений в последние несколько лет, помимо реляционных было разработано много других баз данных "специального назначения". Примерами могут служить базы данных, основанные на парах "ключ-значение" и предназначенные для обработки исключительно больших объемов данных (в общем случае на них ссылаются как на NoSQL), графовые базы данных и документные базы данных. Чтобы помочь разработчикам в поддержке таких баз данных и не усложнять модель доступа к данным Spritag, был создан отдельный проект под названием Spring Data (http: //proj ects. spring. io/ spring-data). Этот проект в дальнейшем был разделен на различные категории с целью поддержки более специфических требований по доступу к данным.
На заметку! Поддержка нереляционных баз данных в Spring в моем блоге не рассматривается. Для тех, кто интересуется этой темой, упомянутый ранее проект Spring Data будет хорошей отправной точкой. На странице проекта указаны нереляционные базы данных, которые он поддерживает, а также предоставлены ссылки на домашние страницы для этих баз данных.
Поддержка JDBC в Spring делает построений приложения на основе JDBC вполне реальным, даже в особо сложных случаях. Поддержка Hibemate, JDO и JPA еще более упрощает и без того простые АРТ-интерфейсы, сокращая затраты на кодирование со стороны разработчиков. При использовании API-интерфейсов Spring для доступа к данным через любой инструмент имеется возможность получить все преимущества великолепной поддержки транзакций, предлагаемой Spring.
Одним из самых полезных средств Spring является возможность простого комбинирования технологий доступа к данным в рамках приложения. Например, приложение может работать с базой данных Oracle, но использовать Hibemate для большей части логики доступа к данным. Однако если требуются некоторые специфичные для Oracle средства, очень просто реализовать соответствующую часть уровня доступа к данным с помощью API-интерфейсов JDBC, поддерживаемых Spring.
Поддержка Object to XML Mapping (ОХМ) в Spring
Многие приложения должны интегрироваться или предоставлять службы для других приложений. Одним из распространенных требований является обмен данными с другими системами, либо на ре^лярной основе, либо в реальном времени. Наиболее распространенным форматом данных считается XML. В результате возникает необходимость в преобразовании компонента JavaBean в формат XML и наоборот.
Платформа Spring поддерживает много общепринятых инфраструктур отображения Java в XML и, как обычно, устраняет потребность в непосредственной привязке к любой специфической реализации. Spring предоставляет общие интерфейсы для маршализации (преобразования компонентов JavaBean в XML) и демаршализации (преобразования XML в объекты Java) для внедрения зависимостей в любые бины Spring. Поддерживаются такие распространенные библиотеки, как Java Architecture for XML Binding (JAXB), Castor, XStream, JiBX и XMLBeans.
Управление транзакциями
Платформа Spring предлагает удобный уровень абстракции для управления транзакциями, который позволяет осуществлять программный и декларативный контроль над транзакциями. За счет применения уровня абстракции для транзакций упрощается смена лежащего в основе протокола транзакций и диспетчеров ресурсов. Вы можете начать с простых, локальных, специфичных для ресурса транзакций и затем перейти к глобальным, мультиресурсным транзакциям, не изменяя уже написанного кода.
Упрощение и интеграция с JEE
Благодаря растущему принятию инфраструктур 01, таких как Spring, многие разработчики решили строить приложения, используя инфраструктуры DI для поддержки подхода EJB из JEE. В результате сообщество JCP также столкнулось со сложностью EJB. Начиная с версии 3.0 спецификации EJB, доступный АР^интерфейс был упрощен и теперь включает многие концепции DI.
Тем не менее, для приложений, которые были построены на EJB или должны развертывать Spring-приложения в контейнере JEE и пользоваться корпоративными службами сервера приложений (например, диспетчер транзакций JTA (Java Transaction API - API-интерфейс транзакций Java), пул подключений к источникам данных и фабрики подключений JMS), Spring также предлагает упрощенную поддержку указанных технологий. Для EJB платформа Spring предоставляет простое объявление, позволяющее выполнять поиск JNDI и внедрять в бины Spring. На противоположной стороне Spring также обеспечивает простую аннотацию для внедрения бинов Spring в компоненты ЕJВ.
Для любых ресурсов, сохраненных в местоположении, которое доступно через JNDI, платформа Spring позволяет избавиться от сложного кода поиска и внедрять ресурсы, управляемые JNDI, как зависимости в другие объекты во время выполнения. В качестве побочного эффекта приложение становится не привязанным к JNDI, увеличивая степень многократного использования кода в будущем.
MVC на веб-уровне
Хотя платформа Spring может применяться практически в любых конфигурациях, от настольной системы до веб, она предлагает широкий спектр классов, предназначенных для поддержки создания веб-приложений. Благодаря Spring, вы получаете максимальную гибкость при выборе способа реализации пользовательского интерфейса для веб-приложения.
Наиболее популярным шаблоном, который используется при разработке веб-приложений, является MVC. В последних версиях Spring постепенно развилась от простой веб-платформы до полноценной реализации MVC.
Прежде всего, следует отметить обширную поддержку представлений в Spring MVC. В дополнение к стандартной поддержке JSP и JSTL (Java Standard Tag Library — стандартная библиотека дескрипторов Java), которая значительно подкреплена библиотеками дескрипторов Spring, в распоряжении разработчиков имеется полностью интегрированная поддержка Apache Velocity, FreeMarker, Apache Tiles и XSLT. Кроме того, доступен набор базовых классов представлений, которые упрощают добавление к приложениям вывода Microsoft Excel, PDF и JasperReports.
Во многих случаях вы сочтете поддержку Spring MVC вполне достаточной для удовлетворения потребностей ваших веб-приложений. Однако Spring может также интегрироваться с другими популярными веб-платформами, такими как Struts, JSF, Atmosphere, Google Wfeb Toolkit (GWT) и т.д.
В последние годы технология веб-платформ стремительно развивалась. Пользователи требовали более быстрого отклика и высокой интерактивности, и это привело к появлению Ajax — широко распространенной технологии для разработки насыщенных Интернет-приложений (Rjch Internet Application — RIA). С другой стороны, пользователи также хотят иметь доступ к своим приложениям на любом устройстве, включая смартфоны и планшеты. Это порождает необходимость в вебплатформах, которые поддерживают HTML5, JavaScript и CSS3.
Поддержка WebSocket
Начиная с версии Spring Framework 4.0, доступна поддержка интерфейса Java API для WebSocket (JSR-356). В WfebSocket определен API-интерфейс для создания постоянного подключения между клиентом и сервером, обычно реализованного в веб-браузерах и серверах. Разработка в стиле WfebSocket открывает простор для эффективных двухсторонних коммуникаций, которые делают возможным обмен сообщениями в реальном времени для быстрореагирующих приложений.
Поддержка удаленных технологий
Доступ или отображение удаленных компонентов в Java никогда не было простой работой. Имея дело с платформой Spring, вы можете получить в свое распоряжение обширную поддержку большого диапазона удаленных технологий для быстрого отображения и доступа к удаленным службам.
Платформа Spring предлагает поддержку разнообразных механизмов удаленного доступа, в том числе RMI (Java Remote Method Invocation — удаленный вызов методов Java), JAX-WS, протоколы Hessian и Burlap от Caucho, JMS, AMQP (Advanced Message Queuing Protocol — расширенный протокол очередизации сообщений) и REST. В дополнение к этим удаленным протоколам, Spring также предоставляет собственный вызывающий объект на основе НТТР, базирующийся на стандартной сериализации Java. За счет применения возможностей динамического создания прокси, предлагаемых платформой Spring, прокси для удаленного ресурса внедряется в качестве зависимости в ваши классы, что устраняет необходимость привязки приложения к специфической реализации удаленной технологии и сокращает объем кода, который должен быть написан для приложения.
Поддержка электронной почты
Отправка электронной почты является типичным требованием для многих видов приложений и полноценно поддерживается в Spring Framework. Платформа Spring предоставляет упрощенный API-интерфейс для отправки сообщений электронной почты, который хорошо согласуется с возможностями Spring DI. В Spring поддерживается стандартный интерфейс JavaMail API.
Spring позволяет создать сообщение-прототип в контейнере DI и использовать его в качестве основы для всех сообщений, отправляемых из приложения. Это упрощает настройку параметров почтового сообщения, таких как тема и адрес отправителя. Вдобавок для настройки тела сообщения платформа Spring интегрируется с механизмами шаблонов вроде Apache Velocity, которые дают возможность вынести содержимое сообщений за пределы Jаvа-кода.
Поддержка планирования заданий
Большинство нетривиальных приложений требуют определенных возможностей планирования. Возможность планирования запуска кода в заранее определенный момент времени представляет собой очень полезное средство для разработчиков, для чего бы это не делалось - для отправки обновлений заказчикам или для выполнения служебных задач.
Платформа Spring предлагает поддержку планирования, которая удовлетворяет требованиям большинства распространенных сценариев. Задача может быть запланирована на запуск либо с фиксированным интервалом, либо с применением выражения для Unix-утилиты cron.
С другой стороны, для выполнения и планирования задач платформа Spring также интегрируется с другими библиотеками планирования. Например, в среде сервера приложений Spring может делегировать выполнение библиотеке CommonJ, которая используется многими серверами приложений. Для планирования задач Spring также поддерживает несколько библиотек, в числе которых JDK Timer API и Quartz, представляющие собой известные библиотеки планирования с открытым кодом.
Поддержка динамических сценариев
Начиная с JDK 6, в Java появилась поддержка динамических языков, которая позволяет запускать сценарии, написанные на других языках, в среде JVM. Примерами таких языков могут служить Groovy, JRuby и JavaScript.
Платформа Spring также поддерживает выполнение динамических сценариев в Spring-приложении. Кроме того, можно определить Spring-бин, написанный на языке динамических сценариев, и внедрить его в нужные компоненты JavaBean. В число языков динамических сценариев, поддерживаемых Spring, входят Groovy, JRuby и BeanShell.
Упрощенная обработка исключений
Существует область, в которой Spring действительно помогает сократить объем повторяющегося рутинного кода — обработка исключений. Основой философии Spring в этом отношении является тот факт, что проверяемые исключения используются в Java чрезмерно, и платформа не должна принуждать к перехвату любого исключения, после которого вряд ли будет возможность провести восстановление — мы полностью разделяем такую точку зрения.
В действительности многие платформы спроектированы так, чтобы сократить потребность в написании кода для обработки проверяемых исключений. Тем не менее, во многих таких платформах принято придерживаться проверяемых исключений, но искусственно снижать степень детализации в иерархии классов исключений. В отношении Spring вы отметите интересный момент: вследствие удобства, которое получают разработчики благодаря применению непроверяемых исключений, иерархия классов исключений является в высшей степени детальной.
Повсеместно в моем блоге вы будете встречать примеры, в которых механизмы обработки исключений Spring могут уменьшать объем необходимого кода и в то же время совершенствовать возможности идентификации, классификации и диагностики ошибок внутри приложения.
