Как настроить класс как Spring Bean?
Термин «бин» используется в Spring для ссылки на любой компонент, который управляется контейнером. То есть бины – это объекты, являющиеся основой приложения и управляемые Spring IoC-контейнером. Как правило, на определенном уровне бины придерживаются спецификации JavaBean, однако это необязательно, особенно когда для связывания бинов друг с другом разработчик планирует использовать Constructor Injection.
Чтобы получить экземпляр бина, применяют ApplicationContext. При этом IoC-контейнер управляет жизненным циклом бина, а также областью видимости и внедрением.
Если говорить о конфигурационном файле Spring Bean, то он имеет особое значение. В частности, он определяет все бины, которые будут инициализированы в Spring Context. При этом в процессе создания экземпляра Spring ApplicationContext конфигурационный xml-файл будет прочитан, следовательно, будут выполнены необходимые инициализации, указанные в этом файле. Также в этом файле, отдельно от базовой конфигурации, могут быть настройки локализации, описания перехватчиков (interceptors) и прочее.
Итак, существует ряд способов работы с классами в Spring Framework:
- XML-конфигурация,
- Java based-конфигурация
- конфигурация Annotation based.
Давайте рассмотрим их чуть подробнее.
XML-конфигурация
Java based-конфигурация
В данном случае все настройки и указания бинов прописывают в Java-коде:
При этом для извлечения бина из контекста применяют следующий подход:
Annotation based-конфигурация
Ее можно использовать внутри кода аннотации @Repository, @Component, @Service, @Controller, что делается для указания классов в качестве Spring-бинов. А для их поиска и управления контейнером в xml-файл прописывают следующую настройку:
Saved searches
Use saved searches to filter your results more quickly
Cancel Create saved search
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.
YuraFedorov-tech/PreProject6
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Switch branches/tags
Branches Tags
Could not load branches
Nothing to show
Could not load tags
Nothing to show
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Cancel Create
- Local
- Codespaces
HTTPS GitHub CLI
Use Git or checkout with SVN using the web URL.
Work fast with our official CLI. Learn more about the CLI.
Sign In Required
Please sign in to use Codespaces.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
Latest commit message
Commit time
README.md
Spring. Первые шаги
Spring Framework (сокр. Spring) — фреймворк для разработки энтерпрайз приложений. Спринг позволяет создавать масштабируемые и легко поддерживаемые решения, что сильно ускоряет разработку.
Данный фреймворк имеет высокую модульность, каждый модуль способен запускаться и выполнять свои задачи как самостоятельное приложение, либо же может использоваться в группе с другими модулями (фреймворки в фреймворке). Функционал спринга постоянно обновляется и дополняется, наиболее популярные модули реализуют функционал MVC, работы с базой данных, секьюрности приложений, обмена сообщений, шаблонизаторов и многого другого.
Как это работает
Bean — объект, управляемый спрингом. В спринге все будет бинами: и сервисы, и ДАО, и контроллеры (группы сервлетов).
DI-контейнер — технология, держащая в себе бины и отвечающая за их связь. Например дао подтягивать к сервису будет именно этот контейнер. Но вашим кодом это не ограничится, контейнер позволит запускать различные модули без жесткой связи между собой, так в модуль Security не потребуется передавать все контроллеры из модуля MVC, контейнер свяжет их неявно.
Контекст — окружение, в котором запускается приложение. Их реализовано более десятка, но чаще всего используется следующие 3 версии
— FileSystemXmlApplicationContext; — xml конфиг, раньше был распространен, сейчас устарел после ввода аннотаций в java 1.6 — AnnotationConfigApplicationContext; — современный контекст, основывается на аннотациях, изучать будем его. — StaticApplicationContext — переходный вариант, прямо в коде связываем бины, используется для тестирования
И в обратную сторону: Контейнер + метаданные (настройки) позволяют запустить образуют ваше приложение с контейнером, который управляет бинами.
Первая задача. HelloWorld.
Всего 3 класса и одна зависимость.
Класс App содержит метод мейн, с которого запускается спринг при создании контекста. В контекст мы передаем класс AppConfig, который помечен аннотацией @Configuration, так спринг понимает, что это настроечный класс.
В классе AppConfig содержится метод, помеченный аннотацией как бин, этот метод будет выполнен при запуске и его результат станет объектом управляемым спрингом.
Класс HelloWorld является обычным джава-классом, мы его используем без каких-либо сложностей.
В методе мейн мы можем получить бин ХеллоВорлд по имени и использовать в любом месте программы.
Спринг позволяет использовать различные типы бинов, одни будут жить от старта до завершения программы, другие будут создаваться при каждом реквесте или открытии новой сессии, третьи при каждом вызове будут создаваться новые. За это отвечает аннотация @Scope.
- Прочитайте про виды бинов
- Создайте POJO-class Cat
- в кассе AppConfig по аналогии создайте бин с именем “cat”.
- Настройте этот бин так, чтобы он создавался новым при каждом запросе.
- В классе App по аналогии вызовите еще раз бин HelloWorld, затем 2 раза вызовите бин cat. Сравните 2 пары бинов по ссылке и выведите результат в консоль. Для пары хэлловорлдов должно вернуться тру, для кэт — фоллзс. Так вы можете увидеть результат того, как работает наш контейнер.
Задача 2. Spring Beans
Теперь поработаем со связыванием бинов. Вызывать бины из контекста хорошо, но не так удобно, как связывать их автоматически.
Для работы аннотаций связывания, я добавил в мавен ядро спринга, так мы имеем совершенно рабочее спринг приложение, хоть и без дополнительных модулей.
В компоненте AnimalCage есть поле типа Animal, которое связано с помощью аннотации @Autowired. При выполнении программы DI-контейнер потянет сюда бин, подходящий по типу.
- Создайте бин Dog, унаследуйте его от Animal. Создайте на основе этого класса компонент.
- Запустите приложение и проверьте, что было выброшено исключение NoUniqueBeanDefinitionException. Это произошло из-за того, что по типу Animal существует 2 бина и спринг выбросит исключение. Прочитайте по связыванию бинов по имени и свяжите AnimalCage c бином Dog через интерфейс Animal.
- На основе класса Timer создайте бин. Свяжите с AnimalCage. Проверьте, что при выполнении метода мейн время, которое пишет таймер, одно и тоже.
Задача 3. Виды связывания бинов.
«На море на океане есть остров, на том острове дуб стоит, под дубом сундук зарыт, в сундуке — заяц, в зайце — утка, в утке — яйцо, в яйце — игла, — смерть Кощея»
Зависимости остались прежние. В упражнении появился компонент Кощей Бессмертный (KoscheiTheDeathless), который расскажет, где находится его смерть, если вызвать метод getRulesByDeth() . Для описания поиска смерти использованы классы в папке models. Для вашего удобства они были пронумерованы: Ocean1, Island2, Wood3 и так далее.
Чтобы спринг видел все бины, в классе AppConfig была добавлена аннотация @ComponentScan.
В спринге связать бины можно различными способами, рассмотрим их на примере:
- KoscheiTheDeathless связывается с Ocean1 через сеттер setOcean и аннотации аутовайрд над ней.
- Ocean1 связан с Island2 через поле и аннотацию, которая подтянет бин Island2 через метод getIsland() в классе AppConfig. Обратите внимание, что данный метод обозначен аннотацией @Bean, что автоматически подтягивает аргументы в метод. В качестве аргумента выступает бин Wood3
- бин Wood3 помечен компонентом, который конструируется через связывание по @Autowired конструктору.
Собрать цепочку до 8го элемента, использовав все вышеперечисленные методы связывания. После выполнения вы должны получить полную фразу.
Вопросы для самопроверки:
- Что такое бин
- Виды бинов
- Чем бин отличается от POJO класса?
- Что такое Inversion of Control и как Spring реализует этот принцип.
- Для чего существует такое количество ApplicationContext.
- Как можно связать бины
- Что такое Dependency Injection
- Какие бины будут использоваться для настройки приложения?
Подготовка к Spring Professional Certification. Контейнер, IoC, бины
Сегодня я решил представить вам перевод цикла статей для подготовки к Spring Professional Certification.
Это перевод только первой статьи, если он зайдет аудитории, я продолжу выпуск переводов.
Зачем я это делаю, ведь уже есть куча профильных материалов?
- Часто в них информация не структурирована, не собрана, или не актуальна
- Молодые разработчики могут не знать английский. Этот цикл можно использовать не только для сертификации, но и для самообучения/повторения материалов.
- Этими материалами можно пользоваться при подготовке к собеседованию, т.к. они выстроены в виде вопросов и ответов.
- Важное, и самое главное преимущество — этот QA сделан из вопросов из официального Study Guide от Pivotal.
- Некоторые вопросы, которые казались мне лишними или которых не было в гиде я осознанно упустил.
Оглавление
- Внедрение зависимостей, контейнер, IoC, бины
- AOP (аспектно-ориентированное программирование)
- JDBC, транзакции, JPA, Spring Data
- Spring Boot
- Spring MVC
- Spring Security
- REST
- Тестирование
Сразу напишу список источников, из которых автор брал материалы
- Spring 5 Design Patterns
- Spring in Action 4th edition
- Spring Security — Third Edition
- Core Spring 5 Certification in Detail by Ivan Krizsan
- Spring Documentation and Spring API javadocs
Что такое внедрение зависимостей(DI) и в чем его преимущества?
Внедрение зависимостей — это специальный паттерн, который уменьшает связь между Spring компонентами. Таким образом, при применении DI, ваш код становится чище, проще, его становится легче понять и тестировать.
Согласно паттерну DI, создание объектов для зависимостей переходит на фабрику или отдается третьей стороне. Это означает, что мы можем сосредоточиться на использовании этих объектов вместо их создания.
Преимущества DI
- Уменьшенная связь между частями приложения
- Улучшенное тестирование
- Улучшенная архитектура приложения
- Уменьшает шаблонный код
- Стандартизирует разработку приложения
Почему для создания Spring beans рекомендуются интерфейсы?
- Улучшенное тестирование. В тестах бин может быть заменен специальным объектом(mock или stub), который реализует интерфейс бина.
- Позволяет использовать механизм динамических прокси из JDK(например, при создании репозитория через Spring Data)
- Позволяет скрывать реализацию
Что такое application context?
В Spring Framework интерфейс org.springframework.factory.BeanFactory предоставляет фабрику для бинов, которая в то же время является IoC контейнером приложения. Управление бинами основано на конфигурации(java или xml).
Интерфейс org.springframework.context.ApplicationContext — это обертка над bean factory, предоставляющая некоторые дополнительные возможности, например AOP, транзакции, безопасность, i18n, и т.п.
Что такое контейнер и какой у него жизненный цикл?
Основа Spring Framework — контейнер, и наши объекты «живут» в этом контейнере.
Контейнер обычно создает множество объектов на основе их конфигураций и управляет их жизненным циклом от создания объекта до уничтожения.
Контейнер — это объект, реализующий интерфейс ApplicationContext.
Жизненный цикл контейнера
- Контейнер создается при запуске приложения
- Контейнер считывает конфигурационные данные
- Из конфигурационных данных создается описание бинов
- BeanFactoryPostProcessors обрабатывают описание бина
- Контейнер создает бины используя их описание
- Бины инициализируются — значения свойств и зависимости внедряются в бин
- BeanPostProcessor запускают методы обратного вызова(callback methods)
- Приложение запущено и работает
- Инициализируется закрытие приложения
- Контейнер закрывается
- Вызываются callback methods
Как создать экземпляр ApplicationContext?
Spring обеспечивает несколько разновидностей контекста.
Есть несколько основных реализаций интерфейса ApplicationContext:
- FileSystemXmlApplicationContext
- ClassPathXmlApplicationContext
- AnnotationConfigApplicationContext
- XmlWebApplicationContext
- AnnotationConfigWebApplicationContext
Примеры создания контекста:
ApplicationContext ctx = new FileSystemXmlApplicationContext( "c:/bean_properties.xml"); ApplicationContext ctx = new AnnotationConfigApplicationContext( "com.springdemoapp.JavaConfig.class");Можете ли вы описать жизненный цикл бина в контейнере?
- Загрузка описаний бинов, создание графа зависимостей(между бинами)
- Создание и запуск BeanFactoryPostProcessors
- Создание бинов
- Spring внедряет значения и зависимости в свойства бина
- Если бин реализует метод setBeanName() из интерфейса NameBeanAware, то ID бина передается в метод
- Если бин реализует BeanFactoryAware, то Spring устанавливает ссылку на bean factory через setBeanFactory() из этого интерфейса.
- Если бин реализует интерфейс ApplicationContextAware, то Spring устанавливает ссылку на ApplicationContext через setApplicationContext() .
- BeanPostProcessor это специальный интерфейс(о нем ниже), и Spring позволяет бинам имплементировать этот интерфейс. Реализуя метод postProcessBeforeInitialization() , можно изменить экземпляр бина перед его(бина) инициализацией(установка свойств и т.п.)
- Если определены методы обратного вызова, то Spring вызывает их. Например, это метод, аннотированный @PostConstruct или метод initMethod из аннотации @Bean .
- Теперь бин готов к использованию. Его можно получить с помощью метода ApplicationContext#getBean() .
- После того как контекст будет закрыт(метод close() из ApplicationContext), бин уничтожается.
- Если в бине есть метод, аннотированный @PreDestroy , то перед уничтожением вызовется этот метод. Если бин имплементирует DisposibleBean, то Spring вызовет метод destroy() , чтобы очистить ресурсы или убить процессы в приложении. Если в аннотации @Bean определен метод destroyMethod , то вызовется и он.
Как получить ApplicationContext в интеграционном тесте?
Если вы используете JUnit 5, то вам нужно указать 2 аннотации:
- @ExtendWith(TestClass.class) — используется для указания тестового класса
- @ContextConfoguration(classes = JavaConfig.class) — загружает java/xml конфигурацию для создания контекста в тесте
Можно использовать аннотацию @SpringJUnitConfig , которая сочетает обе эти аннотации.
Для теста веб-слоя можно использовать аннотацию @SpringJUnitWebConfig .
Как завершить работу контекста в приложении?
Если это не веб-приложение, то есть 2 способа:
- Регистрация shutdown-hook с помощью вызова метода registerShutdownHook() , он также реализован в классе AbstractApplicationContext. Это предпочтительный способ.
- Можно вызвать метод close() из класса AbstractApplicationContext.
В Spring Boot приложении:
- Spring Boot самостоятельно зарегистрирует shutdown-hook за вас.
Что такое Java-конфигурация? Как она применяется?
Чтобы создать класс с конфигурацией на основе Java-кода, нужно аннотировать его с помощью
@Configuration .
Этот класс будет содержать фабричные методы для создания бинов в контейнере.
Эти методы должны быть аннотированы аннотацией @Bean .
@Configuration public class DSConfig < @Bean public DataSource dataSource() < return DataSourceBuilder .create() .username("") .password("") .url("") .driverClassName("") .build(); >>Этот класс поместит в контейнер экземпляр класса DataSource. Позднее его можно будет использовать при доступе к базе данных.
DI используя аннотации, сканирование классов
Component scanning(сканирование компонентов) — Spring автоматически обнаруживает бины, которые будут находиться в контейнере. Это бины с аннотациями-стереотипами.
Однако сканирование компонентов не включено по умолчанию.
Чтобы включить сканирование, аннотируйте @Configuration-класс аннотацией @ComponentScanning . Spring будет автоматически сканировать тот пакет, в котором находится этот класс и все его подпакеты.
Можно указать и другие пакеты для сканирования, и даже классы:
//сканирует 2 пакета @Configuration(basePackages = )//сканирует класс @Configuration(basePackageClasses = "MyClass.class")Autowiring(внедрение) — Spring автоматически внедрит зависимости во время сканирования или помещения бина в контейнер.
Для внедрения зависимостей используется аннотация @Autowire .
Что такое stereotypes(аннотации-стереотипы)?
Стереотипы — это аннотации, обозначающие специальную функциональность.
Все стереотипы включают в себя аннотацию @Component .
| Component | Корневая аннотация, которая помечает класс как кандидат для автовнедрения |
| Controller | Указывает, что класс является контроллером для отправления данных на фронт. |
| @RestController | Указывает, что класс является контроллером для REST. Содержит аннотации Controller и @ResponseBody |
| Service | Указывает, что класс является сервисом для выполнения бизнес-логики |
| Repository | Указывает, что класс является репозиторием для работы с бд |
| @Configuration | Указывает, что класс содержит Java-конфигурацию(@Bean-методы) |
Какие существуют области видимости у бинов? Какая у них видимость по умолчанию?
Область видимости — scope, скоуп. Существует 2 области видимости по умолчанию.
| Singleton | Область видимости по умолчанию. В контейнере находится всего 1 экземпляр бина |
| Prototype | В контейнере может находится любое количество экземпляров бина |
И 4 области видимости в веб-приложении.
| Request | Область видимости — 1 HTTP запрос. На каждый запрос создается новый бин |
| Session | Область видимости — 1 сессия. На каждую сессию создается новый бин |
| Application | Область видимости — жизненный цикл ServletContext |
| WebSocket | Область видимости — жизненный цикл WebSocket |
Область видимости указывается с помощью аннотации @Scope на @Bean методах.
Как связаны различные скоупы и многопоточность?
Prototype Scope не потокбезопасный, т.к. он не гарантирует что один и тот же экземпляр будет вызываться только в 1 потоке.
Singleton Scope же наоборот потокобезопасный.
Как создаются бины: сразу или лениво? Как изменить это поведение?
Singleton-бины обычно создаются сразу при сканировании.
Prototype-бины обычно создаются только после запроса.
Чтобы указать способ инициализации, можно использовать аннотацию @Lazy .
Она ставится на @Bean-методы, на @Configuration-классы, или на @Component-классы.
В зависимости от параметра(true или false), который принимает аннотация, инициализация будет или ленивая, или произойдет сразу. По умолчанию(т.е. без указания параметра) используется true.
Что будет если бин с одним скоупом внедрить в бин с другим скоупом?
Singleton bean можно внедрять в любой другой бин.
В сам singleton можно внедрить только prototype или singleton .
Если внедрять prototype, то для каждого singleton будет создан уникальный prototype.
Prototype может быть зависимостью для любого бина.
Внедрять можно только singleton или prototype.
Что такое BeanFactoryPostProcessor и когда он используется?
- BeanFactoryPostProcessor работает над описаниями бинов или конфигурационными метаданными перед тем, как бин будет создан.
- Spring поставляет несколько полезных реализаций BeanFactoryPostProcessor , например, читающий property-файлы и получающий из них свойства бинов.
- Вы можете написать собственную реализацию BFPP.
Зачем вам может понадобится static @Bean-метод?
Для того чтобы использовать кастомный BFPP. Вы можете переопределить механизм получения данных из метафайлов.
@Bean public static PropertySourcesPlaceholderConfigurer pspc() < //создать, сконфигурировать и вернуть pspc >Опишите свойства аннотации @Bean
- destroyMethod — указывает на метод обратного вызова. Метод находится в бине.
- initMethod — указывает на метод обратного вызова. Метод находится в бине.
- name — имя бина. По умолчанию именем бина является имя метода.
- value — алиас для name()
Что такое BeanPostProcessor и чем он отличается от BeanFactoryPostProcessor?
Spring использует несколько BeanPostProcessor’ов.
Например, CommonAnnotationPostProcessor или AutowiredAnnotationBeanPostProcessor .
BPP работает с экземплярами бинов, т.е. контейнер создает бин, а затем начинает работать BPP.
Что такое callback methods и как их использовать?
Есть 3 варианта для создания таких методов:
- @PreDestroy и @PostConstruct аннотации
- Параметры initMethod и destroyMethod в аннотации @Bean , указывающие на методы в классе бина
- Переопределенные InitializingBean#afterPropertiesSet() и DisposableBean#destroy() . Для переопределения этих методов нужно имплементировать соответствующие интерфейсы.
Как можно использовать аннотацию @Autowire и в чем отличие между способами?
Ниже перечислены типы DI, которые могут быть использованы в вашем приложении:
DI через конструктор считается самым лучшим способом, т.к. для него не надо использовать рефлексию, а также он не имеет недостатков DI через сеттер.
DI через поле не рекомендуется использовать, т.к. для этого применяется рефлексия, снижающая производительность.
DI через конструктор может приводить к циклическим зависимостям. Чтобы этого избежать, можно использовать ленивую инициализацию бинов или DI через сеттер.
Опишите поведение аннотации @Autowired
- Контейнер определяет тип объекта для внедрения
- Контейнер ищет бины в контексте(он же контейнер), которые соответствуют нужному типу
- Если есть несколько кандидатов, и один из них помечен как @Primary , то внедряется он
- Если используется аннотации @Autowire + Qualifier , то контейнер будет использовать информацию из @Qualifier , чтобы понять, какой компонент внедрять
- В противном случае контейнер попытается внедрить компонент, основываясь на его имени или ID
- Если ни один из способов не сработал, то будет выброшено исключение
Контейнер обрабатывает DI с помощью AutowiredAnnotationBeanPostProcessor. В связи с этим, аннотация не может быть использована ни в одном BeanFactoryPP или BeanPP.
Если внедряемый объект массив, коллекция, или map с дженериком, то Spring внедрит все бины подходящие по типу в этот массив(или другую структуру данных). В случае с map ключом будет имя бина.
//параметр указывает, требуется ли DI @Authowired(required = true/false)Как произвести DI в private поле?
Вы можете использовать разные типы внедрения:
Как использование @Qualifier дополняет @Autowired?
Spring предоставляет аннотацию Qualifier, чтобы преодолеть проблему неоднозначности при DI.
@Bean @Qualifier("SomeClass1") public SomeClass getField() //… @Autowire @Qualifier("SomeField1") public SomeClass someField;Если в контейнере есть несколько бинов одного типа(SomeClass), то контейнер внедрит именно тот бин, над @Bean-методом которого стоит соответствующий квалификатор. Также можно не ставить квалификатор на метод, а использовать имя бина в качестве параметра квалификатора.
Имя бина можно можно указать через параметр аннотации Bean, а по умолчанию это имя фабричного метода.
Что такое прокси-объекты и какие типы прокси-объектов может создавать Spring?
Прокси это специальный объект, который имеет такие же публичные методы как и бин, но у которого есть дополнительная функциональность.
Два вида прокси:
- JDK-proxy — динамическое прокси. API встроены в JDK. Для него необходим интерфейс
- CGLib proxy — не встроен в JDK. Используется когда интерфейс объекта недоступен
- Позволяют добавлять доп. логику — управление транзакциями, безопасность, логирование
- Отделяет некоторый код(логирование и т.п.) от основной логики
Как внедряется singleton-бин?
Если в контейнере нет экземпляра бина, то вызывается @Bean-метод. Если экземпляр бина есть, то возвращается уже созданный бин.
Что такое профили? Какие у них причины использования?
При использовании Java-конфигурации вы можете использовать аннотацию @Profile .
Она позволяет использовать разные настройки для Spring в зависимости от указанного профиля.
Ее можно ставить на @Configuration и Component классы, а также на Bean методы.
Profile("!test") //загружать со всеми прифилями, кроме теста@Bean("dataSource") @Profile("production") public DataSource jndiDataSource() @Bean("dataSource") @Profile("development") public DataSource standaloneDataSource()
Как внедрить простые значения в свойства в Spring?
Для этого можно использовать аннотацию @Value .
Такие значения можно получать из property файлов, из бинов, и т.п.
@Value("$some.key") public String stringWithDefaultValue;В эту переменную будет внедрена строка, например из property или из view.
Узнайте, как привязать бины Spring с использованием XML и классов Java
Для подключения компонентов Spring используются два подхода: конфигурация XML и класс Java. Привязка может быть выполнена вручную путем настройки XML- файлов или с помощью классов Java. Также можно позволить Spring выполнить привязку на основе нескольких спецификаций.
Основная цель этой статьи – показать, как компоненты Spring могут быть привязаны с помощью двух упомянутых выше подходов.
Обновлено: 2023-10-17 14:17:06 Вадим Дворников автор материала
Для чего используется фреймворк Spring?
Spring Framework — это одна из популярных сред разработки приложений, которая имеет следующие преимущества:
- Использование только нужных модулей.
Spring предлагает множество различных пакетов и классов. А также позволяет использовать только нужные из них. - Возможность применения других технологий .
Spring использует другие технологии: фреймворки логов, ORM, таймеры Quartz, JEE и JDK и другие.
- Компактность
Контейнер Spring легче по сравнению с контейнером EJB. Он развертывать приложения на основе Spring на маломощных компьютерах. - Гибкая система управления транзакциями
Интерфейс управления транзакциями Spring может использоваться обработки как глобальных транзакций (Java Transaction API), так и локальных транзакций (в одной базе данных).
Что такое привязка бинов?
Когда запускается программное приложение, совместно работают сразу несколько объектов (бинов). Также они могут использоваться независимо от других объектов.
Чтобы заставить бины работать вместе, их связывают через введение зависимостей в Spring (привязки). Когда запускается приложение на основе Spring, контекст приложения загружает определения компонентов или объектов из файла конфигурации и связывает их вместе.
Существует два подхода к привязке bean-компонентов в среде Spring:
- Привязка через XML.
- Привязка через классы Java.
Что такое автоматическая привязка?
Существует два способа привязки bean-компонентов в среде Spring:
- Вручную, объявив bean-компоненты с помощью Dependency Injection (DI)
- Позволить контейнеру Spring самостоятельно связать необходимые компоненты.
Последний способ известен как автоматическая привязка. При этом контейнеру Spring нужно указать, как он должен их связывать:
- byName: контейнер Spring ищет бины, для которых в файле конфигурации XML для атрибута auto wire установлено значение byName.
- byType: контейнер ищет бины, для которых в файле конфигурации XML для атрибута auto wire установлено значение byType.
- constructor: выполняется поиск бинов, для которых для атрибута auto wire установлено значение constructor.
- autodetect: способ автоматического подключения — через конструктор. Если он не работает, автоматическое подключение выполняется через параметр byType.
Что такое привязка через Java и XML?
Подключение bean-компонентов Spring может выполняться через классы Java и с помощью конфигурации XML. В этом разделе мы рассмотрим оба варианта:
XML: Подключение выполняется в файле конфигурации XML. Он содержит определения bean-компонентов. Когда запускается приложение, бины вызываются с помощью Dependency Injection (DI). В файле конфигурации необходимо объявить элемент и использовать элементы , .
Классы Java: Необходимо создать класс Spring Configuration и аннотировать класс @Configuration. Класс @Configuration сообщает Spring, что bean-компоненты, которые должны быть подключены и настроены в этом классе.
Настройка среды
Настройка среды для разработки приложений Spring, включает в себя всего три основных шага.
- Настройка Java Development Kit
Загрузите JDK с официального сайта Oracle, а затем установите и настройте его. После этого необходимо задать переменные среды PATH и JAVA_HOME. - Настройка Eclipse IDE
Eclipse можно скачать с официального сайта . После завершения загрузки распакуйте двоичные файлы, а затем установите PATH. - Настройка библиотек Spring
Spring можно скачать здесь . Важно правильно установить CLASSPATH.
Пример приложения
Мы разработаем два приложения. В первом бины будут подключаться с использованием аннотаций, а во втором приложении – с помощью XML-файла конфигурации.
Подключение через аннотации — у нас будет три класса Java, как показано ниже.
Листинг 1: Класс бина
package com.dashboardapp.beanwire; public class BeanWire < private String message; public void setMessage(String message)< this.message = message; >public void getMessage() < System.out.println("Message is : " + message); >>
В следующем классе для информирования контейнера Spring о том, что будет загружен beanWire, используются две аннотации. Аннотация @Configuration сообщает контейнеру Spring, что этот класс является источником определений бина.
Аннотация @Bean информирует среду Spring, что метод вернет объект, который должен быть зарегистрирован как компонент в контексте приложения.
Листинг 2: Класс конфигурации Bean с аннотациями
package com.dashboardapp.beanwire; import org.springframework.context.annotation.*; @Configuration public class BeanWireConfig < @Bean public BeanWire beanwire()< return new BeanWire(); >>
Ниже приведен последний класс для запуска приложения.
Листинг 3: Основной класс для запуска приложения
package com.dashboardapp.beanwire; import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.*; public class BeanWireMain < public static void main(String[] args) < ApplicationContext ctx = new AnnotationConfigApplicationContext(BeanWireConfig.class); BeanWire beanwire = ctx.getBean(BeanWire.class); beanwire.setMessage("Hello Bean. You are wired by annotation. "); beanwire.getMessage(); >>
Когда эта Java-программа будет выполнена, она выдаст следующий результат.
Теперь рассмотрим, как привязывать бины через XML-файл.
Привязка через XML-файл: У нас будет два Java-файла и один XML-файл конфигурации.
Java-класс бина практически аналогичен предыдущему.
Листинг 1: Файл бина
package com.dashboardapp.beanwire; public class BeanWireXML < private String message; public void setMessage(String message)< this.message = message; >public void getMessage() < System.out.println("Message is : " + message); >>
Это XML-файл конфигурации.
Листинг 2: Конфигурационный XML-файл.
Это файл для получения компонента из XML-файла конфигурации и вызова методов.
Листинг 3: Основной Java-файл.
Package com.dashboardapp.beanwire; import org.springframework.context.ApplicationContext; import org.springframework.context.support.FileSystemXmlApplicationContext; public class BeanWireXMLMain < public static void main(String[] args) < ApplicationContext context = new FileSystemXmlApplicationContext( "WebContent/WEB-INF/appConfig.xml"); BeanWireXML beanwireobj = (BeanWireXML)context.getBean("beanwire"); beanwireobj.setMessage("Hello Bean. You are wired by XML config. "); beanwireobj.getMessage(); >>
Запустите приложение, и оно выдаст следующий результат.
Заключение
Автоматическая привязка требует осторожности. Не все привязки могут выполняться с помощью автоматического подключения. Оно не подходит для сложных привязок, и это следует учитывать.
Вадим Дворников автор-переводчик статьи « Learn How to wire Spring Beans by using XML and Java classes »