какие типы autowire есть в spring по типу по имени

Выбор бина для внедрения: @Qualifier, @Named, @Resource

В больших приложениях, основанных на Spring (или любом другом IoC фреймворке), может наступить такой день, когда при внедрении зависимостей образуется неоднозначность: одной зависимости удовлетворяет сразу несколько бинов, ведь выбор производится по совместимости типов внедряемого и запрашиваемого бинов. Что же тогда произойдёт?

Подготовка

Нам понадобится многомодульный пустой maven проект с Spring и JUnit:

В проекте создадим интерфейс и две его реализации:

Неоднозначные бины

Для начала я бы хотел посмотреть, что жё всё таки будет, если мы объявим конкурс «Два бина на одно место» 🙂 Поскольку Spring поддерживает несколько аннотаций для связывания зависимостей, я решил попробовать их все:

Код, который неоднозначен:

И тестовый класс к нему. Так как тесты отличаются только именем пакета и именем тестируемого класса, достаточно будет показать лишь один:

Результат исполнения немного предсказуем:

Неявный выбор бина по имени

Одно из самых простых решений, это намекнуть Spring’у, какой бин нам нужен, используя имена полей.

Каждый бин в Spring context имеет своё имя. Это име порождается либо из имени класса, либо явно задаётся в xml и grovvy конфигах, либо берётся из имени функции создания бина в java config.

Если мы назовём поле с неоднозначным типом бина по имени бина, Spring сможет самостоятельно сделать правильным выбор:

Неявное определение типа по имени работает со всеми аннотациями:

Явное указание бина по имени

Для тех, кто не любит ‘convention-over-configuration’, в Spring есть аннотация @Qualifier, позволяющая явно задать имя нужного бина:

Тесты остаются теми же самыми и точно так же проходят:

@Qualifier и задание бина по типу

Для использования этой аннотации вначале нужно определить собственную аннотацию, уникальную для каждого бина:

И применить эту аннотацию и к классу бина и к зависимости:

@Named как другой способ указания бина по имени

JSR-330 помимо нового @Qualifier принёс и аналог старого, который называется @Named и ведёт себя аналогичным образом:

@Resource и всё ещё указание бина по имени

Нужно…больше…бинов…

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

Порядок внедрения бинов не определён. Внедрение коллекции бинов работает со всеми аннотациями.

Заключение и рекомендации

С другой стороны, выбор между специализацией бина по имени или по типу упирается в вопрос удобства и безопасности. Специализация по типу, с @Qualified из JSR-330 однозначно связывает требуемый бин с его реализацией, но требует достаточно много подготовительного кода. Специализация по имени не требует код вообще, но может привести к неожиданным результатам, если имя будет не то или не у того бина.

Код примера доступен на github. Тесты модуля fail специально оставлены проваливающимися.

Источник

Русские Блоги

Spring @Autowired и три способа запустить автоматическое сканирование

Предисловие:

@Autowired определение кода аннотации

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

1. Введение в сценарии использования аннотаций @Autowired

Во-вторых, основная часть аннотации @Autowired

Фактически, когда запускается Spring IoC, контейнер автоматически загружает постпроцессор AutowiredAnnotationBeanPostProcessor. Когда контейнер сканирует @Autowied, @Resource или @Inject, он автоматически находит требуемый bean-компонент в контейнере IoC и объединяет его со свойствами объекта.

При использовании @Autowired сначала запросите соответствующий тип bean-компонента в контейнере,

Вышеупомянутый процесс показывает, что аннотация @Autowired вводится в соответствии с типом сборки по умолчанию. По умолчанию она требует, чтобы зависимый объект существовал. Если ему разрешено иметь значение null, вы можете установить для его обязательного атрибута значение false. Если вы хотите передать инъекцию в соответствии с именем, вам необходимо объединить @ Квалификатор используется вместе;

3. Устраните неоднозначность автоматической сборки с помощью аннотации @Autowired.

Если в процессе использования аннотаций @Autowired возникает исключение NoUniqueBeanDefinitionException, это в основном связано с неоднозначностью, вызванной автоматической сборкой или другими методами сборки. То есть существует более двух классов реализации для интерфейса. То есть во время автоматической сборки может возникнуть тяжелая ситуация. NoUniqueBeanDefinitionException вызвано проблемой имени.

@Autowired собирается по типу, поэтому у меня есть интерфейс UserInterface с несколькими классами реализации

И так далее, эти классы реализации добавляются в контейнер Spring, когда в классе используется следующий оператор:

Ниже перечислены вышеупомянутые проблемы и аналогичные решения неоднозначности сборки.

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

В настоящее время, если имеется ссылка на внедрение класса реализации интерфейса IUserService, сначала внедряется класс аннотации @Promary, но на данный момент существует проблема. В классе реализации того же интерфейса вы можете использовать @Primary только один раз. Если для AImpl Используются как @primary, так и BImpl, и неоднозначность сборки по-прежнему будет возникать.В настоящее время рекомендуется использовать метод (1) для решения проблемы неоднозначности.

Метод третий

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

В-четвертых, какие функции Spring обеспечивает автоматическая сборка?

Spring реализует автоматизированную сборку с двух точек зрения:

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

В-пятых, разница между @Autowired и @Resource

В этой статье перечислены только общие поверхностные различия между @Autowired и @Resource.Что касается причины различия, вам необходимо проверить реализацию аннотации @Autowired в официальной документации Spring и реализацию аннотации @Resource в Java.

(1) @Autowired внедряется в соответствии со сборкой типа по умолчанию. По умолчанию для этого требуется, чтобы зависимый объект существовал. Если ему разрешено иметь значение null, вы можете установить для его обязательного атрибута значение false. Если вы хотите передать инъекцию в соответствии с именем, вам необходимо объединить @Qualifier использовать вместе;

(2) @Resource по умолчанию собирает инъекцию в соответствии с именем.Только когда не удается найти bean-компонент, соответствующий имени, инъекция собирается в соответствии с типом;

(3) аннотация @Resource предоставляется J2EE, а @Autowired предоставляется Spring, поэтому для уменьшения зависимости системы от Spring рекомендуется использовать @Resource;

(4) И @Resource, и @Autowired могут быть записаны и отмечены в поле или в методе установки поля.

(5) @Resource собирается в соответствии с именем по умолчанию. Когда bean-компонент, соответствующий имени, не найден, он будет собран в соответствии с типом, который можно указать с помощью атрибута name. Если атрибут имени не указан, когда аннотация отмечена в поле, поле берется по умолчанию Имя используется в качестве имени компонента для поиска зависимого объекта.Когда аннотация помечена в методе установки атрибута, имя атрибута используется в качестве имени компонента для поиска зависимого объекта по умолчанию. Примечание: если атрибут имени не указан, и зависимый объект не может быть найден в соответствии с именем по умолчанию В это время он вернется к сборке по типу, но как только атрибут name будет указан, его можно будет собрать только по имени.

В-шестых, как Spring запускает автоматическое сканирование

Вот три способа запустить автоматическое сканирование.

метод первый:В этом случае, для более особой ситуации, то есть в проекте используется SpringBoot, вы можете использовать аннотацию @SpringBootApplication для запуска функции автоматического сканирования.

Путь второй: В режиме конфигурации XML запустите функцию автоматического сканирования. Режим конфигурации XML.

Тег будет включать автоматическое сканирование Spring Beans и может установить атрибут base-package, что означает, что Spring будет сканировать все классы, оформленные @Component в этом каталоге и подкаталогах, и собирать их.

Путь третий: С помощью метода настройки Java запустите функцию автоматического сканирования.

Вот конкретный пример:

(2) @ComponentScan означает открытие сканирования Spring Beans, аналогично конфигурации XML, здесь вы также можете установить атрибут basePackages. Чтобы

Если аннотация @ComponentScan не показывает, чтобы присвоить значения другим атрибутам, например, присвоить значения базовым пакетам здесь, если нет, аннотация @ComponentScan будет сканировать пакеты с тем же классом конфигурации.

Что касается использования четырех аннотаций @Repository, @Service, @Controller и @Component
На уровне сохраняемости, бизнес-уровне и уровне управления @Repository, @Service и @Controller используются для аннотирования классов на уровне, а @Component используется для аннотирования более нейтральных классов. Это означает, что этот класс передан Spring для управления, а имя переименовано в userManager.Поскольку трудно сказать, к какому уровню принадлежит этот класс, используется @Component.

Семь, сколько методов сборки существует в Spring?

В настоящее время в Spring есть три метода сборки:

8. Использование @Autowired в @Configuration для аннотирования ошибок IDE.

заглавие

Источник

Аннотация @Autowired: что к чему?

Решил рассказать немного про аннотацию @Autowired. Принцип её работы очень прост.

Допустим у нас есть bean-зависимости:

И есть класс сервиса:

И при создании контекста Spring автоматически определит, что для создания MyService требуется bean типа ServiceDependency (или наследник), найдёт его у себя, в рамках подставит зависимость ServiceDependencyImpl в bean MyService.

На самом деле, начиная со Spring 4.0 аннотацию @Autowired можно не ставить на конструктор, если он единственный в классе.

Другие варианты использования аннотации

@Autowired можно ставить непосредственно на поле. Да-да, это будет работать и с private-полями:

Также аннотацию можно ставить на сеттеры:

Но можно так же ставить и на отдельные методы, например:

Что ещё?

Предположим, что бинов типа ServiceDependency несколько (допустим dependency1 и dependency2). Тогда, чтобы задать конкретный bean, необходимо использовать аннотацию @Qualifier:

А если мы захотим использовать все бины?

Сделать это можно простым способом:

И Spring вставит (удивительно) все бины, реализующие интерфейс ServiceDependency. То же самое верно и для типизированных коллекций. Как ни странно, но порядком следования в этой коллекции можно управлять с помощью аннотации @Order.

Но самое замечательное, вот это:

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

Есть вопрос? Напишите в комментариях!

Источник

Подготовка к Spring Professional Certification. Контейнер, IoC, бины

Доброго времени суток, Хабр.

Сегодня я решил представить вам перевод цикла статей для подготовки к Spring Professional Certification.

Это перевод только первой статьи, если он зайдет аудитории, я продолжу выпуск переводов.

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

В Spring Framework интерфейс org.springframework.factory.BeanFactory предоставляет фабрику для бинов, которая в то же время является IoC контейнером приложения. Управление бинами основано на конфигурации(java или xml).

Интерфейс org.springframework.context.ApplicationContext — это обертка над bean factory, предоставляющая некоторые дополнительные возможности, например AOP, транзакции, безопасность, i18n, и т.п.

Основа Spring Framework — контейнер, и наши объекты «живут» в этом контейнере.
Контейнер обычно создает множество объектов на основе их конфигураций и управляет их жизненным циклом от создания объекта до уничтожения.

Контейнер — это объект, реализующий интерфейс ApplicationContext.

Spring обеспечивает несколько разновидностей контекста.

Есть несколько основных реализаций интерфейса ApplicationContext:

Примеры создания контекста:

Если вы используете JUnit 5, то вам нужно указать 2 аннотации:

Если это не веб-приложение, то есть 2 способа:

В Spring Boot приложении:

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

Component scanning(сканирование компонентов) — Spring автоматически обнаруживает бины, которые будут находиться в контейнере. Это бины с аннотациями-стереотипами.

Область видимости — scope, скоуп. Существует 2 области видимости по умолчанию.

И 4 области видимости в веб-приложении.

Область видимости указывается с помощью аннотации @Scope на @Bean методах.

Prototype Scope не потокбезопасный, т.к. он не гарантирует что один и тот же экземпляр будет вызываться только в 1 потоке.

Singleton Scope же наоборот потокобезопасный.

Singleton-бины обычно создаются сразу при сканировании.
Prototype-бины обычно создаются только после запроса.

Singleton bean можно внедрять в любой другой бин.

Prototype может быть зависимостью для любого бина.
Внедрять можно только singleton или prototype.

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

Есть 3 варианта для создания таких методов:

Ниже перечислены типы DI, которые могут быть использованы в вашем приложении:

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

Контейнер обрабатывает DI с помощью AutowiredAnnotationBeanPostProcessor. В связи с этим, аннотация не может быть использована ни в одном BeanFactoryPP или BeanPP.

Если внедряемый объект массив, коллекция, или map с дженериком, то Spring внедрит все бины подходящие по типу в этот массив(или другую структуру данных). В случае с map ключом будет имя бина.

Вы можете использовать разные типы внедрения:

Spring предоставляет аннотацию Qualifier, чтобы преодолеть проблему неоднозначности при DI.

Если в контейнере есть несколько бинов одного типа(SomeClass), то контейнер внедрит именно тот бин, над @Bean-методом которого стоит соответствующий квалификатор. Также можно не ставить квалификатор на метод, а использовать имя бина в качестве параметра квалификатора.
Имя бина можно можно указать через параметр аннотации Bean, а по умолчанию это имя фабричного метода.

Прокси это специальный объект, который имеет такие же публичные методы как и бин, но у которого есть дополнительная функциональность.
Два вида прокси:

Если в контейнере нет экземпляра бина, то вызывается @Bean-метод. Если экземпляр бина есть, то возвращается уже созданный бин.

В эту переменную будет внедрена строка, например из property или из view.

Как обычно, просьба присылать правки или найденные ошибки в личку.

Источник

Введение в Spring, или что делать, если по всему проекту @Autowired и @Component, а вы не понимаете, что это

Приветствую тебя, Хабр!

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

Начнем издалека. Существует такое понятие как Inversion of Control, по-русски – Инверсия управления, сокращенно – IoC. IoC — один из принципов, приближающий наш код к слабосвязанности. IoC — это делегирование части наших обязанностей внешнему компоненту.

Существуют разные реализации IoC подхода, нас интересует одна из них — Dependency Injection, внедрение зависимостей. Что это такое, название говорит само за себя, так что раскрыть ее я постараюсь на примере. Мы пишем приложение, автоматизирующее работу сети магазинов. Есть классы Shop (магазин) и Seller (продавец). У класса Seller имеется поле типа Shop — магазин, в котором работает продавец. Вот мы и столкнулись с зависимостью: Seller зависит от Shop. Теперь задумаемся, как в объект Seller попадет объект Shop? Есть варианты:

Перечисленные два способа — это реализация Dependency Injection (но пока еще это не IoC). И, наконец, мы подобрались к спрингу: он предоставляет еще один способ внедрять зависимости (а тут уже IoC).

Вообще говоря, Spring — это очень широкий набор библиотек на многие случаи жизни. Существует и Spring MVC для быстрого создания веб-приложений, и Spring Security для реализации авторизации в приложении, и Spring Data для работы с базами данных и еще куча всего. Но отдельно стоит Spring IoC — это базовый вид спринга, который реализует изучаемую нами тему — внедрение зависимостей. Spring IoC заслуживает внимания в самом начале изучения библиотек спринга по еще одной причине. Как вы увидите в процессе практической работы с другими видами спринга, для всех остальных спрингов Spring IoC используется как каркас.

Знакомство со Spring IoC начнем с главного термина: бин (англ. — bean). Самыми простыми словами,

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

Бин — объект класса, представляющий собой завершенный программный элемент с определенной бизнес-функцией либо внутренней функцией Spring’а, жизненным циклом которого управляет контейнер бинов.

Как вы уже поняли, для того, чтобы в Seller можно было внедрить Shop, Shop должен стать бином. Существует несколько способов рассказать приложению, какие объекты имеют гордое право называться бинами, все они приводят нас к понятию ApplicationContext. ApplicationContext — это сердце спринга. Как правило, он создается в самом начале работы приложения («поднимается») и управляет жизненным циклом бинов. Поэтому его еще называют контейнером бинов.

Подбираемся к главному. Каким образом нам необходимо переписать наши классы, чтобы Spring IoC и его слуга ApplicationContext подставили значение поля Shop объекту Seller? Вот таким:

Просто? Куда уж проще! Элегантно? Вполне. Здесь произошло следующее: аннотация Component сказала спрингу, что класс, который ей аннотируем, это бин. Аннотация Autowired попросила Spring в поле, которое она аннотирует, подставить значение. Эта операция называется «инжектнуть» (inject). Какое именно значение будет подставлено? Об этом чуть позже, сначала разберемся, как вообще классы становятся бинами.

Мы уже знаем, что в начале работы приложения должен подняться хранитель всех бинов ApplicationContext. Он-то и создает сразу все бины. Почти все. Дело в том, что по умолчанию любой бин имеет внутриспринговое свойство scope в значении singleton. Внутриспринговое, так как синглтоном в прямом смысле слова он не является. Он является синглтоном для спринга: при поднятии контекста Spring создаст ровно один объект-бин из указанного класса. Если вы хотите изменить такое поведение — пожалуйста, Spring разрешает управлять временем создания бина и их количеством для одного класса, но сейчас не об этом.

Итак, при поднятии ApplicationContext создаются все бины. Давайте выясним, а собственно где живет контекст и самое главное: как он определяет, из каких классов необходимо создавать бины. Вариантов несколько, для простоты изложения мы поговорим про один из них: конфигурирование с помощью файла xml. Вот его пример:

В этом файле продемонстрирован запуск создания бинов двумя путями. Первый, скажем так, ручной. Видите, здесь есть тег bean с указанием класса. Это и есть бин. Из всего, что прописано в этом файле с тегом bean, будут созданы бины.

Второй путь менее многословен. Помните, над классами мы поставили аннотацию Component. Из всех классов, аннотированных этой аннотацией, будут созданы бины. Благодаря этой строке из xml-файла:

Она говорит спрингу: просканируй весь пакет main и из всего, над чем будет стоять аннотация Component (или другие аннотации, являющиеся наследниками Component), создай бины. Компактно, не правда ли? Просто говорим, в каких пакетах содержатся классы, из которых нужно создавать бины, и аннотируем эти классы.

Поднять контекст с использованием xml-файла можно следующей строчкой кода:

где beans.xml — путь к xml-нику, о котором шла речь выше.

С созданием бинов разобрались. Каким же образом Spring заполнит поле Shop при создании Seller’а? При поднятии контекста создается бин-объект класса Shop. Также создается бин-объект класса Seller, он же тоже аннотирован Component. У него есть поле типа Shop, аннотированное Autowired. Аннотация Autowired говорит спрингу: в это поле нужно инжектнуть бин. В нашем случае у нас есть всего один бин, подходящий на эту роль, то есть тип которого совпадает с типом поля: это бин — экземпляр класса Shop. Он и будет проинжектен в объект Seller, что и требовалось. Я понимаю, сейчас вопросики полезли как червячки: а что будет, если Spring не найдет нужный бин, или найдет несколько подходящих (особенно учитывая, что инжектить можно также по интерфейсу, а не по классу). Spring умен, но требует того же и от нас. Нам нужно либо иметь в системе ровно один бин, подходящий под каждый Autowired, либо обучать Spring действиям при таких конфликтах (об этом мы сейчас не будем, вы и так устали, крепитесь, статья подходит к концу).

Заметьте, что Seller – это тоже бин. Если бы он был не бином, а создавался через new, то автоматически бы ничего в него не проинжектнулось.

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

Возможно вы сейчас думаете, как красиво, просто и лаконично Spring позволяет внедрять зависимости. Но представьте, что что-то пошло не так и вам необходимо дебажить приложение. И все становится уже не так просто…

Парочка хинтов напоследок:

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

UPD (20.04.2021). Dependency Injection это не всегда IoC! В самом начале я как раз привожу примеры Dependency Injection, не являющиеся IoC.

Источник