Узнайте, как привязать бины Spring с использованием XML и классов Java
Для подключения компонентов Spring используются два подхода: конфигурация XML и класс Java. Привязка может быть выполнена вручную путем настройки XML- файлов или с помощью классов Java. Также можно позволить Spring выполнить привязку на основе нескольких спецификаций.
Основная цель этой статьи – показать, как компоненты Spring могут быть привязаны с помощью двух упомянутых выше подходов.
Для чего используется фреймворк Spring?
Spring Framework — это одна из популярных сред разработки приложений, которая имеет следующие преимущества:
Spring использует другие технологии: фреймворки логов, ORM, таймеры Quartz, JEE и JDK и другие.
Что такое привязка бинов?
Когда запускается программное приложение, совместно работают сразу несколько объектов (бинов). Также они могут использоваться независимо от других объектов.
Чтобы заставить бины работать вместе, их связывают через введение зависимостей в Spring (привязки). Когда запускается приложение на основе Spring, контекст приложения загружает определения компонентов или объектов из файла конфигурации и связывает их вместе.
Существует два подхода к привязке bean-компонентов в среде Spring:
Что такое автоматическая привязка?
Существует два способа привязки bean-компонентов в среде Spring:
Последний способ известен как автоматическая привязка. При этом контейнеру Spring нужно указать, как он должен их связывать:
Что такое привязка через Java и XML?
Подключение bean-компонентов Spring может выполняться через классы Java и с помощью конфигурации XML. В этом разделе мы рассмотрим оба варианта:
.
Классы Java: Необходимо создать класс Spring Configuration и аннотировать класс @Configuration. Класс @Configuration сообщает Spring, что bean-компоненты, которые должны быть подключены и настроены в этом классе.
Настройка среды
Настройка среды для разработки приложений Spring, включает в себя всего три основных шага.
Пример приложения
Мы разработаем два приложения. В первом бины будут подключаться с использованием аннотаций, а во втором приложении – с помощью XML-файла конфигурации.
Подключение через аннотации — у нас будет три класса Java, как показано ниже.
Листинг 1: Класс бина
В следующем классе для информирования контейнера Spring о том, что будет загружен beanWire, используются две аннотации. Аннотация @Configuration сообщает контейнеру Spring, что этот класс является источником определений бина.
Аннотация @Bean информирует среду Spring, что метод вернет объект, который должен быть зарегистрирован как компонент в контексте приложения.
Листинг 2: Класс конфигурации Bean с аннотациями
Ниже приведен последний класс для запуска приложения.
Листинг 3: Основной класс для запуска приложения
Когда эта Java-программа будет выполнена, она выдаст следующий результат.
Теперь рассмотрим, как привязывать бины через XML-файл.
Привязка через XML-файл: У нас будет два Java-файла и один XML-файл конфигурации.
Java-класс бина практически аналогичен предыдущему.
Листинг 1: Файл бина
Это XML-файл конфигурации.
Листинг 2: Конфигурационный XML-файл.
Это файл для получения компонента из XML-файла конфигурации и вызова методов.
Листинг 3: Основной Java-файл.
Запустите приложение, и оно выдаст следующий результат.
Заключение
Автоматическая привязка требует осторожности. Не все привязки могут выполняться с помощью автоматического подключения. Оно не подходит для сложных привязок, и это следует учитывать.
Дайте знать, что вы думаете по данной теме материала в комментариях. За комментарии, отклики, подписки, лайки, дизлайки огромное вам спасибо!
Пожалуйста, опубликуйте свои комментарии по текущей теме материала. Мы крайне благодарны вам за ваши комментарии, подписки, лайки, дизлайки, отклики!
Java Blog
Spring IoC контейнер: Java конфигурация, @Bean и @Configuration
Центральными артефактами поддержки Java-конфигурации Spring с использованием new являются @Configuration-аннотированные классы и @Bean-аннотированные методы.
Предыдущий класс AppConfig эквивалентен следующему Spring XML:
Полная @Configuration против «облегченного» режима @Bean?
Когда методы @Bean объявляются в классах, которые не аннотируются @Configuration, они называются обработанными в «облегченном» режиме. Методы bean-компонентов, объявленные в @Component или даже в простом классе с другой основной целью содержащего класса, считаются «облегченными», а метод @Bean является своего рода бонусом. Например, сервисные компоненты могут предоставлять представление управления контейнеру с помощью дополнительного метода @Bean для каждого применимого класса компонентов. В таких сценариях методы @Bean являются механизмом фабричного метода общего назначения.
В отличие от полной @Configuration, облегченные @Bean методы не могут объявлять межбиновые зависимости. Вместо этого они оперируют внутренним состоянием содержащего их компонента и, необязательно, аргументами, которые они могут объявлять. Поэтому такой метод @Bean не должен вызывать другие методы @Bean. Каждый такой метод является буквально только фабричным методом для конкретной ссылки на компонент, без какой-либо специальной семантики времени выполнения. Положительным побочным эффектом здесь является то, что подклассы CGLIB не должны применяться во время выполнения, поэтому нет никаких ограничений с точки зрения разработки класса (то есть, содержащий класс может быть final и т. д.).
В обычных сценариях методы @Bean должны объявляться в классах @Configuration, гарантируя, что всегда используется «полный» режим и поэтому ссылки на перекрестные методы перенаправляются в управление жизненным циклом контейнера. Это предотвращает случайный вызов одного и того же метода @Bean посредством обычного вызова Java, что помогает уменьшить тонкие ошибки, которые трудно обнаружить при работе в «облегченном» режиме.
Как 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 поможет вам сэкономить уйму времени, которое вы могли потратить на монотонную и ненужную работу.
Для тех, кто хочет знать больше:
Этот материал – не редакционный, это – личное мнение его автора. Редакция может не разделять это мнение.
Собеседование по Java EE — Spring Framework (вопросы и ответы). Часть 1
Вопросы и ответы на собеседование по теме Spring Framework. Часть 1.
к списку вопросов раздела JEE
Вопросы
1. Расскажите о Spring Framework.
2. Какие некоторые из важных особенностей и преимуществ Spring Framework?
3. Что вы понимаете под Dependency Injection (DI)?
4. Как реализуется DI в Spring Framework?
5. Какие преимущества использования Spring Tool Suite?
6. Приведите названия некоторых важных Spring модулей.
7. Что вы понимаете под аспектно-ориентированным программированием (Aspect Oriented Programming — AOP)?
8. Что такое Aspect, Advice, Pointcut, JoinPoint и Advice Arguments в АОП?
9. В чем разница между Spring AOP и AspectJ АОП?
10. Что такое IoC контейнер Spring?
11. Что такое Spring бин?
12. Какое значение имеет конфигурационный файл Spring Bean?
13. Какие различные способы настроить класс как Spring Bean?
14. Какие вы знаете различные scope у Spring Bean?
15. Что такое жизненный цикл Spring Bean?
16. Как получить объекты ServletContext и ServletConfig внутри Spring Bean?
17. Что такое связывание в Spring и расскажите об аннотации @Autowired?
18. Какие различные типы автоматического связывания в Spring?
19. Является ли Spring бин потокобезопасным?
20. Что такое контроллер в Spring MVC?
21. Какая разница между аннотациями @Component, @Repository и @Service в Spring?
22. Расскажите, что вы знаете о DispatcherServlet и ContextLoaderListener.
23. Что такое ViewResolver в Spring?
24. Что такое MultipartResolver и когда его использовать?
25. Как обрабатывать исключения в Spring MVC Framework?
26. Как создать ApplicationContext в программе Java?
27. Можем ли мы иметь несколько файлов конфигурации Spring?
28. Какие минимальные настройки, чтобы создать приложение Spring MVC?
29. Как бы вы связали Spring MVC Framework и архитектуру MVC?
30. Как добиться локализации в приложениях Spring MVC?
31. Как мы можем использовать Spring для создания веб-службы RESTful, возвращающей JSON?
32. Приведите пример часто используемых аннотаций Spring.
33. Можем ли мы послать объект как ответ метода обработчика контроллера?
34. Как загрузить файл в Spring MVC?
35. Как проверить (валидировать) данные формы в Spring Web MVC Framework?
36. Что вы знаете Spring MVC Interceptor и как он используется?
37. Spring JdbcTemplate класс и его применение.
38. Как использовать Tomcat JNDI DataSource в веб-приложении Spring?
39. Каким образом можно управлять транзакциями в Spring?
40. Расскажите о Spring DAO.
41. Как интегрировать Spring и Hibernate?
42. Расскажите о Spring Security.
43. Как внедрить java.util.Properties в Spring Bean?
44. Назовите некоторые из шаблонов проектирования, используемых в Spring Framework?
45. Best Practices в Spring Framework.
Ответы
1. Расскажите о Spring Framework.
Spring Framework (или коротко Spring) — универсальный фреймворк с открытым исходным кодом для Java-платформы. Несмотря на то, что Spring Framework не обеспечивает какую-либо конкретную модель программирования, он стал широко распространённым в Java-сообществе главным образом как альтернатива и замена модели Enterprise JavaBeans. Spring Framework предоставляет бо́льшую свободу Java-разработчикам в проектировании; кроме того, он предоставляет хорошо документированные и лёгкие в использовании средства решения проблем, возникающих при создании приложений корпоративного масштаба. Обычно Spring описывают как облегченную платформу для построения Java-приложений, но с этим утверждением связаны два интересных момента. Во-первых, Spring можно использовать для построения любого приложения на языке Java (т.е. автономных, веб приложений, приложений JEE и т.д.), что отличает Spring от многих других платформ, таких как Apache Struts, которая ограничена только веб-приложениями. Во-вторых, характеристика “облегченная” в действительности не имеет никакого отношения к количеству классов или размеру дистрибутива; напротив, она определяет принцип всей философии Spring — минимальное воздействие. Платформа Spring является облегченной в том смысле, что для использования ядра Spring вы должны вносить минимальные (если вообще какие-либо) изменения в код своего приложения, а если в какой-то момент вы решите больше не пользоваться Spring, то и это сделать очень просто. Обратите внимание, что речь идет только о ядре Spring — многие дополнительные компоненты Spring, такие как доступ к
данным, требуют более тесной привязки к Spring Framework.
2. Какие некоторые из важных особенностей и преимуществ Spring Framework?
Spring Framework обеспечивает решения многих задач, с которыми сталкиваются Java-разработчики и организации, которые хотят создать информационную систему, основанную на платформе Java. Из-за широкой функциональности трудно определить наиболее значимые структурные элементы, из которых он состоит. Spring Framework не всецело связан с платформой Java Enterprise, несмотря на его масштабную интеграцию с ней, что является важной причиной его популярности.
Spring Framework, вероятно, наиболее известен как источник расширений (features), нужных для эффективной разработки сложных бизнес-приложений вне тяжеловесных программных моделей, которые исторически были доминирующими в промышленности. Ещё одно его достоинство в том, что он ввел ранее неиспользуемые функциональные возможности в сегодняшние господствующие методы разработки, даже вне платформы Java. Этот фреймворк предлагает последовательную модель и делает её применимой к большинству типов приложений, которые уже созданы на основе платформы Java. Считается, что Spring Framework реализует модель разработки, основанную на лучших стандартах индустрии, и делает её доступной во многих областях Java. Таким образом к достоинствам Spring можно отнести:
3. Что вы понимаете под Dependency Injection (DI)?
Внедрение зависимости (Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» ( Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единой обязанности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму. К достоинствам применения DI можно отнести:
4. Как реализуется DI в Spring Framework?
Реализация DI в Spring основана на двух ключевых концепциях Java — компонентах JavaBean и интерфейсах. При использовании Spring в качестве поставщика DI вы получаете гибкость определения конфигурации зависимостей внутри своих приложений разнообразными путями (т.е. внешне в XML-файлах, с помощью конфигурационных Java классов Spring или посредством аннотаций Java в коде). Компоненты JavaBean (также называемые POJO (Plain Old Java Object — простой старый объект Java)) предоставляют стандартный механизм для создания ресурсов Java, которые являются конфигурируемыми множеством способов. За счет применения DI объем кода, который необходим при проектировании приложения на основе интерфейсов, снижается почти до нуля. Кроме того, с помощью интерфейсов можно получить максимальную отдачу от DI, потому что бины могут использовать любую реализацию интерфейса для удовлетворения их зависимости.
К типам реализации внедрения зависимостей в Spring относят:
Constructor Dependency Injection — это тип внедрения зависимостей, при котором зависимости компонента предоставляются ему в его конструкторе (или конструкторах).
