Для чего нужен spring framework

Как Spring упрощает жизнь разработчика: что нужно знать о фреймворке

Java Developer в NIX

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

Фреймворк Spring включает в себя два десятка модулей и, конечно, уместить все в одной статье не получится. В этом материале я расскажу об основных модулях (Core):

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

Базовая терминология для работы со Spring

Человека, знакомящегося со Spring, может испугать обилие новых терминов. И авторы статей «для начинающих» иногда оставляют объяснения этих терминов за скобками, полагая, что это уже все знают или и так поймут из названия. Но я считаю, не лишним будем проговорить эти понятия:

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

Зависимость (Dependency) — в контексте Java-приложения зависимостью называют класс B, без которого не может функционировать класс А.

Аннотация — «метка» в исходном коде, которая сама по себе является метадатой, которую потом может использовать компилятор/интерпретатор или же, как в нашем случае, фреймворк.

Бин (Bean) — класс в языке Java, написанный по определенным правилам. Java-бины используются для объединения нескольких объектов в один, благодаря чему достигается удобство в передачи данных.

Также в статье будут часто использоваться термины инверсия контроля (Inversion of Control, Ioc) и внедрение зависимостей (Dependency Injection, DI). Для их объяснения недостаточно просто определения, поэтому детально рассмотрим их ниже.

IoC и DI

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

Инверсия контроля (Inversion of Control — IoC ) — один из популярных принципов объектно-ориентированного программирования (ООП). Она позволяет повысить модульность и расширяемость программы за счет снижения зависимостей между ее компонентами.

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

Как это выглядит в коде

Давайте выразим в коде пример зависимости уже упомянутых выше машины и двигателя. Первую версию кода напишем без использовании инверсии контроля:

Код без инверсии контроля

Основные недостатки такого подхода:

Этот код можно немного улучшить, добавив интерфейс:

Инверсии контроля можно достичь различными способами, но в Spring чаще всего применяются способы Dependency Injection (DI; от англ. «внедрение зависимостей»). Рассмотрим именно их.

Давайте добьемся инверсии контроля при помощи DI-метода: Setter Injection (пока что без Spring Framework):

Setter Injection, пока что без Spring Framework

Внедрение зависимостей можно также осуществить с помощью Construction Injection, где аргументы будут переданы через конструктор:

Пример без Spring Framework, но с инверсией управления Constructor Injection

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

Вместе с этим осталась нерешенной следующая проблема: новые классы по прежнему нужно создавать при помощи оператора new (хотя теперь это и делается снаружи исходного кода):

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

Добавляем Spring Framework в приложение

Любой ресурс (класс) в Spring называется бином (Bean). Это название взято по аналогии с JavaBeans — классами в языке Java, написанными по определенным правилам (наличие конструктора без параметров, геттеров/сеттеров). Бины в Spring не ограничены такими строгими правилами, но они очень похожи на своих Java-собратьев.

Чтобы добавить Spring в приложение, вам необходимо:

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

XML-конфигурация на Spring

Код приложения с использованием Spring Framework будет выглядеть точно так же, как и без него. В этом и заключается то самое «минимальное воздействие», характерное для Spring.

Пример приложения на Spring Framework

XML-конфигурацию этого кода можно представить следующим образом:

XВ первой части кода есть масса ссылок. Так в Spring выглядит пространство имен. Но давайте сосредоточим внимание на выделенной области кода. Здесь можно увидеть объявление наших бинов:

Пример приложения на Spring Framework — XML-конфигурация

Annotation-конфигурация на Spring

Рассмотрим создание конфигураций на Spring при помощи аннотаций (annotation). Они помогут Spring разобраться, где именно существуют зависимости, и что ему нужно с ними делать. Уберем из нашего config.xml все упоминания о бинах и пропишем необходимость сканирования пакета на наличие аннотации @Component :

Пример приложения на Spring Framework — Annotation конфигурация

Пример приложения на Spring Framework — Annotation конфигурация

Начиная с версии Spring 4.3, аннотацию @Autowired необязательно ставить на конструктор. Если у нас в коде лишь один конструктор, Spring автоматически определит его как место внедрения зависимостей. Но в случае установки аннотации @Autowired на сеттер ее всегда следует прописывать явно.

Java-конфигурация на Spring

Пример приложения на Spring Framework — Java конфигурация: слева — конфигурация, справа — код

XML или Annotation?

Какой же подход лучше всего подойдет для создания конфигураций на Spring: XML или аннотации? На мой взгляд, это вопрос вкуса:

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

Основные аннотации Spring: внедрение зависимостей с помощью @Autowired

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

Аннотация @Autowired отвечает в Spring за внедрение зависимостей. Ею можно пометить место внедрения (сеттер, поле или конструктор), и Spring автоматически свяжет нужный бин с этим местом. Используем в нашем коде внедрение зависимости через сеттер с помощью @Autowired :

Создадим Java-конфигурацию вместе с аннотацией @ComponentScan — с ее помощью нам больше не нужно будет явно указывать наши бины в коде:

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

Сonstructor Injection

Внедрение через конструктор следует использовать когда зависимость является обязательной, или ее необходимо сделать неизменяемой (с помощью ключевого слова final ).

Благодаря Constructor Injection также легче заметить «суперклассы» — перегруженные классы с большим количеством зависимостей. Если в классе все зависимости подключаются через конструктор, то в глаза сразу бросается большое количество параметров. И у разработчика появится ощущение, что он делает что-то не так.

Setter Injection

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

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

Field Injection и основные причины его избегать

Внедрение зависимостей при помощи Field Injection не рекомендуется делать по нескольким причинам:

Setter или Constructor Injection?

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

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

Bean Scopes и их разновидности

@Scope(“singleton”)

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

@Scope(“prototype”)

Скоупы web-приложения

Существует целый ряд бин-скоупов, характерных только для веб-приложений. С их помощью можно ограничивать жизненный цикл экземпляра одним запросом ( request ), сессией ( session ), сервлетом ( application ) или веб-сокетом ( websocket ).

Жизненный цикл бина: использование @PostConstruct и @PreDestroy

Перед тем, как спринговый бин будет доступен к использованию, он проходит ряд этапов своего «рождения».

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

Без ошибок: аннотация @Qualifier

Три компонента одного @Component

У аннотации @Component существует три аналога:

Вместо вывода

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

Для тех, кто хочет знать больше:

Этот материал – не редакционный, это – личное мнение его автора. Редакция может не разделять это мнение.

Источник

Что такое Spring? Обзор фреймворка Java

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

В этой статье вы ознакомитесь с платформой Spring Framework без анализа крупных примеров или изучения подробных объяснений.

Что такое Spring?

Пожалуй, наиболее трудной частью объяснения технологии Spring является точная классификация того, что она собой представляет. Обычно Spnng описывают как облегченную платформу для построения Jаvа-приложений, но с этим утверждением связаны два интересных момента.

Во-первых, Spring можно применять для построения любого приложения на языке Java (например, автономных, веб-приложений или приложений Java Enterprise Edition (JEE)) в отличие от многих других платформ (таких как Apache Struts, которая ограничена созданием только веб-приложений).

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

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

Эволюция Spring Framework

Платформа Spring Framework берет начало из книги Рода Джонсона Experl One-on-One: J2EE Design and Development (Wox, 2002 г.). За прошедшее десятилетие Spring Framework значительно выросла в плане основной функциональности, связанных проектов и поддержки со стороны сообщества. Теперь, когда доступен новый крупный выпуск Spring Framework, полезно взглянуть на важные средства, которые появились в каждом промежуточном выпуске Spring, в конечном итоге приведя к выходу Spring Framework 4.0.

Инверсия управления или внедрение зависимостей?

На заметку! Применение термина внедрение зависимостей при ссылке на инверсию управления всегда корректно. В контексте Spring эти термины можно использовать взаимозаменяемо, совершенно не теряя при этом смысла.

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

Эволюция внедрения зависимостей

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

В JEE 6 документ JSR-330 стал одной из спецификаций, входящих в полный комплект технологий. За это время архитектура EJB (начиная с версии 3.0) также была существенно модернизирована; с целью упрощения разработки разнообразных приложений Enterprise JavaBeans была принята модель DI.

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

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

За пределами внедрения зависимостей

Поддержка 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.

Ниже перечислено несколько особенностей.

На заметку! Начиная с версии Spring Framework 3.2, поддержка аннотации @AspectJ может быть включена с помощью Java Config.

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

АОП имеет много применений. Типичное применение, демонстрируемое во множестве традиционных примеров АОП, связано с выполнением некоторого вида регистрации, но возможности АОП выходят далеко за рамки тривиальных приложений регистрации. На самом деле внутри самой платформы Spring Framework АОП используется для многих целей, в частности, при управлении транзакциями.

Язык выражений Spring (SpEL)

Проверка достоверности в Spring

Для решения указанных проблем в Spring предлагается встроенный АРL- интерфейс проверки достоверности в виде интерфейса Validator. Этот интерфейс предоставляет простой и лаконичный механизм, который позволяет инкапсулировать логику проверки достоверности в класс, ответственный за проверку достоверности целевого объекта. В дополнение к целевому объекту метод проверки достоверности принимает объект Errors, который используется для сбора любых возникающих ошибок при проверке.

В Spring также имеется полезный служебный класс ValidationUtils, который предлагает удобные методы для вызова других валидаторов, проверки наличия распространенных проблем вроде пустых строк и сообщения об ошибках указанному объекту Errors.

Начиная с версии 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

На заметку! Начиная с версии 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.

Для любых ресурсов, сохраненных в местоположении, которое доступно через 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 могут уменьшать объем необходимого кода и в то же время совершенствовать возможности идентификации, классификации и диагностики ошибок внутри приложения.

Источник