Спринг своими руками

Добавил пользователь Дмитрий К.
Обновлено: 04.10.2024

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

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

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

Базовая терминология для работы со 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 ) — один из популярных принципов объектно-ориентированного программирования (ООП). Она позволяет повысить модульность и расширяемость программы за счет снижения зависимостей между ее компонентами.

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

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

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

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

Здесь видим, что у нас есть класс Engine в котором имеется метод running (предположим, он запускает двигатель). Чтобы осуществить метод drive , нам необходимо сперва проинициализировать экземпляр зависимого класса Engine (проверить, все ли нормально с нашим двигателем).

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

сильная связанность между классами (невозможно разрабатывать класс Car , не делая изменений в классе Engine и наоборот);
такое приложение тяжело изменять, а значит его сложно расширять (поддерживать и обновлять).

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

Так удастся понизить связность, и у нас появится возможность подставить новые реализации ( V8Engine ), не изменяя при этом код в методе drive . Но нам все так же необходимо внимательно следить за тем, какую реализацию мы выбрали. А это изрядно усложняет задачу: если реализаций станет слишком много, в них будет легко запутаться.

Что предлагает сделать инверсия контроля? Вынести создание зависимостей за пределы нашего класса, чтобы не прописывать каждый раз его новые элементы через new . IoC дает возможность вызывать новые элементы класса извне, не меняя при этом исходный код.

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

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

Что изменилось в коде? Был написан специальный метод под названием setEngine , в который мы передали наш двигатель. Теперь нам не нужно вручную создавать каждый новый объект класса engine , а можно передать его в наш класс извне с помощью метода setEngine (как он там создастся — это уже не задача нашего класса).

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

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

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

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

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

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

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

создать Spring-конфигурацию;
задать контекст Spring — под контекстом в этом случае стоит понимать интерфейс ApplicationContext. Он содержит информацию о бинах и их зависимостях, а также общие данные о конфигурации приложения;
получить бины из IoC-контейнера.

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

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

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

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

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

Первый бин — engine . Запрашивая его, можно, например, получить экземпляр класса V8Engine .
Второй бин — car . В этом бине видна зависимость от бина engine , которую внедрили через конструктор (это также можно сделать через сеттер).

Создадим новый класс new PathXmlAplicationContext и передадим ему в аргументы нашу конфигурацию config.xml . Теперь попросим Spring предоставить нам бин car :

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

На этом этапе Spring производит скрытое внедрение зависимостей. Прочитав конфигурацию config.xml , фреймворк будет знать, что для класса car существует зависимость от класса engine . Разработчику больше не придется дополнительно прописывать ее в коде.

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

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

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

Теперь Spring будет автоматически воспринимать бины как классы, отмеченные аннотацией @Component . Места внедрения зависимостей отметим другой аннотацией: @Autowired :

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

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

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

Рассмотрим пример Java-конфигурации на Spring. Полностью удалим наш config.xml и создадим конфигурацию при помощи обычного Java-класса. На него необходимо повесить аннотацию @Configuration и затем внутри кода объявить все используемые бины.

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

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

XML или Annotation?

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

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

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

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

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

Самая популярная в Spring аннотация — определенно @Autowired . И разработчики часто пренебрегают ею, используют в неположенном месте и просто надеются на магию Spring. Давайте разберемся, для чего она нужна, и какие правила использования существуют.

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

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

Существует три вида внедрения зависимостей (DI) при помощи @Autowired , и каждая — со своими правилами применения:

Constructor Injection ;
Setter Injection ;
Field Injection .

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

Сonstructor Injection

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

Setter Injection

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

Setter Injection позволяет делать опциональные зависимости — такие зависимости можно внедрять повторно. Но использование внедрения через сеттер для обязательной зависимости может привести к NullPointerException и остановке приложения. Хоть и существует способ избежать этого с помощью аннотации @Required , все равно следует внимательно следить за этим типом DI.

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

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

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

Setter или Constructor Injection?

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

Но начиная с версии 4.0, команда Spring начала явно выступать за внедрение зависимостей через Constructor . Это позволяет реализовать компоненты приложения как неизменяемые объекты. Таким образом можно гарантировать, что требуемые нам зависимости будут точно проинициализированы.

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

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

@Scope(“singleton”)

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

@Scope(“prototype”)

Singleton -подход предназначен для экономии ресурсов при работе в фреймворке и используется в Spring по умолчанию. Это поведение можно изменить, предварительно указав аннотацию @Scope и внедрив через нее prototype scope . Prototype является полной противоположной singleton : при его внедрении для каждой зависимости будет всегда создаваться новый объект:

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

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

Всегда следует помнить: prototype -зависимость работает только для prototype -компонентов. Именно поэтому в singleton -компоненты нельзя внедрять prototype -зависимости. Можно обойти это ограничение с помощью Method Injection.

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

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

@PostConstruct — метод будет вызван после конструктора;
@PreDestroy — метод будет вызван перед уничтожением бина;

В этих методах удобно инициализировать дополнительные ресурсы или же наоборот — подчищать их после себя. Некоторые методы работают только для singleton , либо только для prototype -компонентов. Если мы используем singleton -компонент, то метод будет вызван только один раз. Однако, совсем неочевидно, что метод @PreDestroy невозможно вызвать для prototype -бинов, когда для каждой зависимости создается новый объект.

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

Если у интерфейса, который внедряется с помощью @Autowired существует несколько реализаций ( engine , electric engine и т.п.), возникнет неопределенность, которая может привести к программной ошибке. Этого можно избежать путем прописывания аннотации @Qualifier . Без добавления аннотации @Qualifier Spring не сможет понять, к какой именно реализации мы хотим обратиться.

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

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

@Controler ;
@Service ;
@Repository .

На сегодня эти аннотации функционально ничем друг от друга не отличаются. Их просто можно использовать в качестве маркеров вместо @Component . Но разработчики не гарантируют, что в будущем у них не появятся новые функции. К примеру, уже сейчас @Repository получила возможность отлавливать Dao-exceptions для репозиториев.

Если вы не можете ответить на вопрос, для какого конкретно случая вы используете аннотацию из списка выше — просто прописывайте @Component .

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

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

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

Самый главный источник — официальная документация. Книга Spring 4(5) для профессионалов. Первые несколько глав будут очень полезны для начинающих.
Практические туториалы.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Этот урок освещает создание каркаса Spring-приложения.

Что вы создадите

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

Что вам потребуется

Настройка проекта

Для начала вам необходимо настроить базовый скрипт сборки. В этом уроке рассмотрим код для работы с Maven. Если вы не знакомы с ним, то ознакомьтесь с соответствующим уроком Сборка Java-проекта с использованием Maven.

Создание структуры каталогов

В выбранном вами каталоге проекта создайте следующую структуру каталогов:

Создание файла сборки Maven

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

На данном этапе проект совсем пустой и без зависимостей. По команде mvn clean install должен появиться каталог target , в котором будет jar-файл проекта.

Добавление модулей Spring Framework

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

Первое, что нам необходимо, это добавить модуль для работы с контекстом и Dependency Injection(DI). Делается это так же, как и для всех остальных зависимостей для Maven в ваш pom.xml :

Аналогичным образом добавляются другие модули, только вместо spring-context подставляется название необходимого модуля. Если же вы хотите загружать версии модулей с оригинального сайта, то вам необходимо указать расположение репозитория в вашей Maven конфигурации:

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

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

Логгирование

По умолчанию, Spring Framework, в частности модуль spring-core использует для логгирования стандартную реализациею Jakarta Commons Logging API (JCL) common-logging , поэтому вам нет необходимости беспокоиться об этой функциональности и о том, что приложение не может быть собрано из-за этой зависимости в других модулях. Однако, если вам по каким-то причинам необходимо использовать другой инструмент логгирования, к примеру, SLF4J, то существуют несколько способов для этого:

Исключить зависимость из spring-core модуля
Некоторые другие способы, описанные в SLF4J FAQ

Для исключения стандартной зависимости по первому способу вам необходимо добавить новые зависимости в секцию dependencyManagement в вашей Maven конфигурации:

Либо добавить к модулю spring-core или зависящему от него модулю подобное. Должно выглядеть примерно так:

Теперь для использования SLF4 вам необходимо добавить в вашу Maven конфигурацию следующее:

Однако более распостраненным способом является использование Logback:

Многие также используют Log4j, Spring предоставляет некоторые утилиты для настройки и инициализации Log4j. Для того, чтобы сделать этот инструмент логгирования по умолчанию, необходимо добавить в ваш корневой каталог приложения конфигурационные файлы( log4j.properties или log4j.xml ) и добавить в вашу Maven конфигурацию следующее:

Ниже приведет пример log4j.properties . Более подробную информацию по настройке, а также использованию Log4j 2.x вы можете найти в документации самого Log4j.

Поздравляем! Вы только что создали каркасный проект будущего Spring-приложения.

Spring Boot Basic Series Tutorial | Часть 2. Использование Spring Initializr в Intellij для быстрой сборки проектов Spring Boot / Cloud

Первоначальная настройка приложения

Переходим на сайт Spring Initializr и подготавливаем минимальный шаблон для нашего будущего приложения:

Создание каркаса проекта

В левой части оставляем настройки по умолчанию, кроме версии Java (будет достаточно 8), и заполняем Project Metadata.

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

Spring Web — модуль, включающий необходимые компоненты для веб-приложения и имеющий встроенный контейнер сервлетов Apache Tomcat.
Spring Data JPA — библиотека, используемая для взаимодействия с сущностями базы данных.
H2 Database — очень удобная база данных. Располагается в памяти, следовательно, хранит данные только пока запущено приложение. Не используется в продакшене, но для знакомства в этом проекте её будет достаточно.
Apache Freemarker — шаблонизатор, будем использовать его для генерации HTML-страниц.

Всё готово, нажимаем GENERATE и получаем архив с исходным кодом проекта. Это минимальный каркас, который импортируем в используемую IDE.

В этом проекте используется IntelliJ IDEA.

Следуем по пути File -> New -> Project from Existing Sources, в диалоговом окне выбираем папку, где находится pom.xml файл проекта. Импортируем проект.

В следующих диалоговых окнах все настройки оставляем по умолчанию. Единственное, в одном из окон удостоверимся, что имеем ранее установленную JDK соответствующей версии, в данном случае 8.

Если JDK не была установлена ранее, её можно скачать с официального сайта.

Все остальные окна кликаем Next и в последнем — Finish.

Кратко рассмотрим структуру проекта. В первую очередь интересны:

файл pom.xml — файл с описанием всех зависимостей, необходимых для приложения;
файл application.properties — файл с настройками проекта;
каталог java — основной каталог пакетов и классов;
каталог resources — каталог для хранения ресурсов (шаблоны, файлы настроек, локализации и т.д.).

Создадим дополнительные пакеты :

entity— для сущностей, в текущем проекте это будет класс Task;
controller— для классов контроллера;
repository— для слоя Repository, интерфейс с описанием общих методов, которые будут использоваться при взаимодействии с базой данных;
service— для классов с бизнес-логикой.

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

Создадим класс Task в пакете entity

Класс помечен аннотацией @Entity. Она указывает на то, что данный класс является сущностью и будет сохраняться в БД.

Данная сущность имеет первичный ключ поле id. Поле помечено аннотацией @Id и аннотацией @GeneratedValue, которая задает стратегию генерации первичного ключа как автоматическую генерацию, в этой сущности – целые числа в порядке возрастания.

Создадим интерфейс TaskRepository в пакете repository

Класс унаследован от JpaRepository – интерфейса фреймворка Spring Data, предоставляющего набор стандартных методов JPA для работы с БД. Для данного приложения нет необходимости создавать дополнительные методы.

Создадим класс TaskService в пакете service

Класс содержит три метода для работы с задачами:

getAll() – метод, возвращающий все задачи, отсортированные в порядке возрастания даты и порядке убывания приоритета.
save(Task task) – метод создания новой задачи.
delete(int id) – метод, удаляющий задачу по переданному id.

Создадим контроллер TaskController в пакете controller

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

Замечание. Более правильно было бы добавить еще один интерфейс TaskService, который будет реализовывать существующий класс TaskService (изменим название на TaskServiceImpl), но в рамках этого приложения делать это не будем.

Создадим index.ftlh – шаблон для Freemarker в каталоге resources/templates

Стандартный HTML-файл. Единственное отличие – это конструкции вида $ и обозначение списка , вместо которых Freemarker подставит нужные нам значения.

Добавим простой CSS-файл style.css в каталоге resources/static/css:

Структура проекта:

Проект готов к запуску и работе

Запускаем первое приложение на Spring Boot

Переходим к классу OrganizerApplication.class. Он был сформирован автоматически на первом шаге конфигурации каркаса проекта. Его содержимое:

Переходим в меню >Run-> Run ‘OrganizerApplication’ или запускаем через сочетание клавиш Shift+F10. Процесс запуска отобразится в консоли ниже.

Переходим в браузер, набираем в адресной строке адрес localhost:8080 и наблюдаем работающий прототип приложения Organizer.

Органайзер на Spring Boot

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

Посмотрите также 10 шпаргалок для веб-разработчика. Там есть видеокурс по Spring Boot.

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

Spring – это облегченный фреймворк, который можно рассматривать как фреймворк фреймворков, поскольку он предлагает поддержку различных фреймворков, таких как Hibernate, Struts, Tapestry, JSF и т. д.

Особенности Spring Framework

Вот некоторые наиболее важные особенности Spring Framework:

Предопределенные шаблоны
облегченный
Быстрое развитие
Мощная абстракция
Предлагает множество ресурсов
Декларативная поддержка
Предлагает комплексные инструменты

Краткая история

Вот важные ориентиры из истории:

Spring Framework был написан Родом Джонсоном и впервые выпущен в июне 2002 года.
Spring La с т версия выпуск в марте 2004 года
Версия Spring 1.2.6 выпущена в 2006 году
Выпуск версии Spring 2.0 в октябре 2006 г.
Выпуск версии Spring 2.5 в ноябре 2007 г.
Выпуск версии Spring 3 в декабре 2009 г.
Выпуск версии Spring 3.1 в декабре 2011 г.
Выпуск версии Spring Framework 4 в декабре 2013 года с поддержкой Java 8
Spring Framework 4.2.0 версия выпущена в июле 2015 года
Spring Framework 4.2.1 версия выпущена в сентябре 2015
Версия Spring Framework 4.3 выпущена 10 июня 2016 года
Spring Framework 5.0 версия выпущена в июне 2017 года

Spring Framework Architecture

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

Core и Bean обеспечивают фундаментальную часть платформы, включая IoC и DI.

Основной контейнер

Базовый контейнер дополнительно разделен на подкомпоненты, такие как модули Core, Beans, Context и Expression Language.

Давайте рассмотрим каждую из этих моделей в деталях:

Основной модуль обеспечивает все основные компоненты каркаса пружины. Включает функции IoC (Inversion of Control) и Inpension Injection.

Модуль предлагает BeanFactory, которая представляет собой сложную реализацию фабричного шаблона.

Context

Модуль Context основан на прочной основе, предоставляемой модулями Core и Beans, и является средой, которая помогает вам получить доступ к любым объектам, определенным и настроенным.

Языки весеннего выражения (SpEL):

Этот модуль предлагает язык выражений для изменения и запроса графов объектов во время выполнения.

Доступ к данным и интеграция:

Уровень доступа к данным и интеграции состоит из модулей JDBC, ORM, JDBC, OXM, JMS и Transaction.

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

Веб-сервлет: Этот модуль хранит реализацию на основе MVC для веб-приложений.

Web-Socket: модуль предлагает основанную на WebSocket и двустороннюю связь между клиентом и сервером в веб-приложениях.

Web-портлет: этот модуль также называется Spring-MVC-Portlet module. Он предлагает портлеты на основе Spring и копирует все функциональные возможности модуля Web-сервлетов.

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

Инструментарий: Этот модуль предлагает инструментарий класса и реализации загрузчика. Используется для конкретных серверов приложений.

Тест: Этот модуль поддерживает тестирование компонентов Spring с помощью инструментов TestNG или JUnit. Он предлагает последовательную загрузку Spring ApplicationContexts и кэширование этих контекстов.

Spring – MVC Framework

Spring Web MVC Framework предлагает архитектуру модель-представление-контроллер и предлагает компоненты, которые помогают вам быть гибкими и слабо связанными веб-приложениями.

Шаблон MVC позволяет разделять различные аспекты приложения, предлагая слабую связь между этими элементами. Spring MVC также помогает вам создавать гибкие и слабо связанные веб-приложения.

Дизайн MVC также позволяет разделить бизнес-логику, логику представления и логику навигации. Он также предлагает элегантное решение для использования MVC в Spring Framework с помощью DispatcherServlet.

Как работает MVC?

DispatcherServlet получает запрос.
После этого DispatcherServlet связывается с HandlerMapping. Он также отзывает контроллер, связанный с этим конкретным запросом.
Контроллер обрабатывает этот запрос, вызывая методы службы и объект ModelAndView, возвращаемый DispatcherServlet.
Имя представления отправляется ViewResolver для поиска фактического представления для вызова.
После этого DispatcherServlet передается в View для отображения результата.
Используя данные модели, представление рендерится и отправляет результат обратно пользователю.

Аспектно-ориентированное программирование

Аспектно-ориентированное программирование позволяет глобальным свойствам программы решать, как она компилируется в исполняемую программу.

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

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

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

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

В Аспектно-ориентированном программировании есть семь основных концепций.

Давайте обсудим их подробно:

Аспект: Аспект – это класс, который позволяет реализовать приложение JEE. Это касается нескольких классов, таких как управление транзакциями, безопасность и т. Д. Аспекты могут быть типичным классом, настроенным с использованием конфигурации Spring XML, или обычным классом, аннотированным с помощью аннотации @Aspect.
Точка соединения: это точка-кандидат в выполнении программы, где аспект может быть подключен. Это может быть метод, вызываемый как выбрасываемое исключение, или даже поле, которое модифицируется.
Совет: Совет – это фактические действия, предпринятые для конкретной точки соединения. Этот метод будет выполняться, когда конкретная точка соединения встречает точку сопоставления в приложении.
Pointcut: Это выражение, которое можно сопоставить с точками соединения, чтобы проверить, следует ли выполнить этот совет или нет.
Целевой объект: на основе целевого объекта применяются устройства. В AOP подкласс создается во время выполнения, где целевой метод должен быть переопределен, и рекомендации включаются в зависимости от их конфигурации.
Прокси: этот объект должен быть создан после применения рекомендации к целевому объекту.
Плетение: это метод связывания аспекта с другими объектами или типами приложения для создания рекомендованного объекта.