Java for Beginner

Варианты ответа:

Anonymous Quiz

25%

MyBean created for singleton, MyBean created for prototype

75%

MyBean created for singleton, MyBean created for prototype, MyBean created for prototype

MyBean created for singleton, MyBean created for singleton, MyBean created for prototype

MyBean created for singleton

MyBean created for singleton, MyBean the power Spring

8 voters118 views15:04

Java for Beginner

Подробный разбор решения задачи Task231024_2

В этой задаче мы изучаем различия между синглтон (singleton) и прототип (prototype) бинами в контексте Spring Framework. Важно понять, как Spring управляет объектами с разными жизненными циклами (scopes) и сколько экземпляров класса создается в зависимости от области действия бина.

1. Конфигурация бинов

Класс Config содержит два бина:
singletonBean() возвращает объект класса MyBean2310 с областью действия singleton.
prototypeBean() возвращает объект того же класса, но с областью действия prototype.

Ключевые аннотации:
@Configuration: указывает на класс, содержащий определение бинов.
@Bean: создает и управляет объектом бина.
@Scope: указывает на область действия бина — singleton или prototype.

2. Класс MyBean2310

В конструкторе этого класса есть строковый параметр scope, который показывает, для какого типа области действия (singleton или prototype) создается объект. При создании объекта этот параметр передается, и выводится сообщение "MyBean created for <scope>".

3. Main-класс

Основной класс программы создает AnnotationConfigApplicationContext, который служит контейнером для Spring-менеджера бинов.

Здесь выполняются следующие действия:
Запрашивается бин singletonBean дважды: оба раза возвращается один и тот же экземпляр.
Запрашивается бин prototypeBean дважды: каждый раз создается новый экземпляр.

4. Ожидаемое поведение

Синглтон-область действия (singleton scope):
Spring создает только один экземпляр бина с областью действия singleton, и этот объект используется во всех запросах к контейнеру.
Вызовы getBean("singletonBean") возвращают один и тот же объект.

Прототип-область действия (prototype scope):
Каждый вызов getBean("prototypeBean") создает новый экземпляр бина, то есть при каждом запросе контейнер создает новый объект.

Пояснение вывода в консоль:
Первая строка выводится при первом вызове context.getBean("singletonBean"). Поскольку бин имеет область синглтон, этот же объект будет возвращаться при каждом последующем запросе, и повторного создания объекта не произойдет.
Вторая строка появляется при первом вызове context.getBean("prototypeBean"), где создается новый экземпляр прототипа.
Третья строка появляется при втором вызове context.getBean("prototypeBean"), где создается еще один новый экземпляр для прототипа.

Основные выводы:
Синглтон-бин создается один раз при первом запросе, и тот же экземпляр используется во всех последующих вызовах.
Прототип-бин создается каждый раз при запросе контейнера, то есть каждый вызов getBean() создает новый объект.

#Solution_TasksSpring

108 views15:29

Java for Beginner

Spring. Внедрение зависимостей через конструктор

Введение в концепцию Dependency Injection (DI)

Dependency Injection (DI) — это один из основных принципов разработки программного обеспечения, основанный на инверсии управления. Этот принцип позволяет классу не создавать свои зависимости самостоятельно, а получать их извне, обычно через конструктор, сеттеры или интерфейсы. DI способствует слабой связанности компонентов и улучшает тестируемость кода.

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

Что такое внедрение зависимостей через конструктор?

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

Когда Spring создает объект (или бин), он автоматически передает все необходимые зависимости в конструктор, используя конфигурацию, определённую в XML-файлах или аннотациях.

Пример внедрения зависимостей через конструктор

Допустим, у нас есть класс NotificationService, который зависит от другого класса MessageService. Вот как можно использовать внедрение через конструктор:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    private final MessageService messageService;

    // Внедрение зависимости через конструктор
    @Autowired
    public NotificationService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
В данном примере класс NotificationService получает зависимость MessageService через конструктор. Аннотация @Autowired сообщает Spring, что нужно автоматически внедрить MessageService в этот конструктор.

#Java #Training #Spring #Dependency_Injection_via_constructor

103 views05:29

Java for Beginner

Конфигурация с использованием аннотаций

Spring поддерживает автоматическое сканирование компонентов и конфигурацию бинов с помощью аннотаций, таких как @Component и @Autowired. Это позволяет избежать необходимости явного определения бинов в XML-файлах.

Создадим основной класс приложения, где Spring контейнер будет автоматически создавать и управлять зависимостями:

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // Получаем бин NotificationService
        NotificationService notificationService = context.getBean(NotificationService.class);

        // Используем сервис для отправки уведомления
        notificationService.sendNotification("Привет, Spring!");
    }
}

Конфигурация с использованием XML

Кроме аннотаций, Spring также поддерживает конфигурацию бинов через XML-файлы. Вот как можно задать внедрение зависимостей через конструктор в XML-конфигурации:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Определение бина MessageService -->
    <bean id="messageService" class="com.example.MessageService"/>

    <!-- Определение бина NotificationService с внедрением через конструктор -->
    <bean id="notificationService" class="com.example.NotificationService">
        <constructor-arg ref="messageService"/>
    </bean>
</beans>
При такой конфигурации Spring автоматически передаст бин messageService в конструктор бина notificationService.

Преимущества внедрения через конструктор

Иммутабельность (неизменяемость): Параметры, переданные через конструктор, становятся неизменными, что улучшает безопасность кода.
Явная зависимость: Использование конструктора делает зависимости явными, так как при создании объекта сразу видно, какие зависимости необходимы для его работы.
Тестируемость: Классы, которые используют внедрение через конструктор, проще тестировать с помощью Mock-объектов (например, с помощью фреймворков Mockito или JUnit), поскольку зависимости можно легко передать в тестах.
Невозможность создания "полуинициализированных" объектов: Все зависимости обязательно передаются в момент создания объекта, что исключает возможность использования объекта без всех необходимых ресурсов.

Когда использовать внедрение через конструктор?

Необходимые зависимости: Когда зависимость обязательна для работы класса, её лучше передавать через конструктор. Это гарантирует, что объект не может быть создан без необходимых зависимостей.
Неизменяемые объекты: Если объект не должен изменяться после создания (например, если его состояние зависит от переданных параметров), лучше использовать конструктор для передачи зависимостей.

#Java #Training #Spring #Dependency_Injection_via_constructor

117 views05:29

Java for Beginner

Что выведет код?

public class Task241024_1 {
    public static void main(String[] args) {
        int a = 5;
        int b = a++ + --a + a-- + ++a;
        System.out.println(b);
    }
}

#Tasks

119 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

17 voters117 views08:48

Java for Beginner

А какие мысли приходят к Вам после 3:00? 🤪🧐😂😂

https://t.me/Java_for_beginner_dev

#Mems

110 views10:29

Java for Beginner

Spring. Внедрение зависимостей через сеттеры

Что такое внедрение зависимостей через сеттеры?

Внедрение через сеттеры — это подход, при котором зависимости передаются в объект с помощью методов-сеттеров. В отличие от внедрения через конструктор, в этом случае зависимости могут быть переданы (или изменены) после создания объекта. Это обеспечивает большую гибкость, особенно если зависимость не обязательна для создания объекта, но может быть добавлена позже.

Spring поддерживает автоматическое внедрение зависимостей через сеттеры с использованием аннотации @Autowired на уровне метода-сеттера или с помощью XML-конфигурации.

Пример внедрения через сеттеры

Давайте рассмотрим пример, где тот же класс NotificationService использует внедрение зависимости через сеттер:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    private MessageService messageService;

    // Внедрение через сеттер
    @Autowired
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
Здесь MessageService внедряется через метод-сеттер setMessageService() с использованием аннотации @Autowired. В отличие от внедрения через конструктор, здесь зависимость может быть изменена в любое время после создания объекта.

Конфигурация через XML

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- Определение бина MessageService -->
    <bean id="messageService" class="com.example.MessageService"/>

    <!-- Определение бина NotificationService с внедрением через сеттер -->
    <bean id="notificationService" class="com.example.NotificationService">
        <property name="messageService" ref="messageService"/>
    </bean>
</beans>
В этом случае Spring вызовет сеттер setMessageService() и передаст бин messageService в качестве зависимости.

#Java #Training #Spring #Dependency_Injection_via_setters

102 views14:09

Java for Beginner

Преимущества и недостатки внедрения через сеттеры

Преимущества:
Гибкость: Внедрение через сеттеры предоставляет большую гибкость, так как зависимости можно изменить или передать после создания объекта.
Удобство для опциональных зависимостей: Если зависимость не обязательна для работы класса и может быть добавлена позже, использование сеттеров становится более подходящим вариантом.
Возможность поздней инициализации: Вы можете инициализировать или менять зависимости в процессе работы приложения.

Недостатки:
Возможность "полуинициализированного" объекта: Так как зависимости могут быть переданы после создания объекта, существует риск того, что объект может быть использован до того, как все зависимости будут установлены.
Явная зависимость менее очевидна: В отличие от внедрения через конструктор, где зависимости видны при создании объекта, здесь необходимо знать, что сеттеры должны быть вызваны после создания объекта, что может быть не так очевидно.

Когда использовать внедрение через сеттеры?

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

Сравнение внедрения через конструктор и через сеттеры

Необходимые зависимости: Внедрение через конструктор лучше подходит для обязательных зависимостей, так как они передаются в момент создания объекта и не могут быть изменены. Сеттеры же подходят для опциональных зависимостей.
Иммутабельность: Конструкторы способствуют созданию неизменяемых объектов, в то время как сеттеры допускают изменение состояния объекта после создания.
Тестируемость: Оба подхода легко тестируются с помощью фреймворков типа Mockito, однако конструкторы делают зависимости более очевидными и уменьшают количество методов для подмены в тестах.

#Java #Training #Spring #Dependency_Injection_via_setters

106 views14:09

Java for Beginner

Что выведет код?

Задача по Spring. Тема: #Dependency_Injection_via_setters и #Dependency_Injection_via_constructor. Сложность средняя.

Подробный разбор через 30 минут!🫡

import org.springframework.context.annotation.*;

@Configuration
class Config2410 {
    @Bean
    public MyService2410 myService2410() {
        return new MyService2410();
    }

    @Bean
    public MyBean2410 setterInjectedBean2410(MyService2410 myService) {
        MyBean2410 bean = new MyBean2410();
        bean.setMyService2410(myService);
        return bean;
    }

    @Bean
    public MyBean2410 constructorInjectedBean2410(MyService2410 myService) {
        return new MyBean2410(myService);
    }
}

class MyService2410 {
    public void serve() {
        System.out.println("Service called");
    }
}

class MyBean2410 {
    private MyService2410 myService;

    public MyBean2410(MyService2410 myService) {
        this.myService = myService;
        System.out.println("Constructor injection");
    }

    public MyBean2410() {
        System.out.println("No-arg constructor");
    }

    public void setMyService2410(MyService2410 myService) {
        this.myService = myService;
        System.out.println("Setter injection");
    }

    public void useService2410() {
        myService.serve();
    }
}

public class Task241024_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config2410.class);

        MyBean2410 setterBean = context.getBean("setterInjectedBean2410", MyBean2410.class);
        MyBean2410 constructorBean = context.getBean("constructorInjectedBean2410", MyBean2410.class);

        setterBean.useService2410();
        constructorBean.useService2410();

        context.close();
    }
}

#TasksSpring

111 views14:59

Java for Beginner

Варианты ответа:

Anonymous Quiz

25%

No-arg constructor, Constructor injection, Setter injection, Service called, Service called

25%

Setter injection, Constructor injection, Service called, Service called

13%

Constructor injection, Service called, Setter injection, Service called

38%

No-arg constructor, Setter injection, Constructor injection, Service called, Service called

8 voters115 views15:04

Java for Beginner

Подробный разбор решения задачи Task241024_2

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

1. Конфигурация бинов

Класс Config2410 содержит два бина:
setterInjectedBean2410() создаёт бин MyBean2410 с использованием сеттер-инъекции.
constructorInjectedBean2410() создаёт бин MyBean2410 с использованием конструкторной инъекции.

Аннотации:
@Configuration: Указывает на класс, содержащий конфигурацию Spring и бинов.
@Bean: Создаёт объект бина и регистрирует его в контексте Spring.

2. Класс MyBean2410

Конструктор с параметром инжектирует зависимость через конструктор и выводит строку "Constructor injection".
Пустой конструктор выводит "No-arg constructor".
Метод setMyService2410() инжектирует зависимость через сеттер и выводит "Setter injection".
Метод useService2410() вызывает метод serve() объекта MyService2410, который выводит "Service called".

3. Класс Task241024_2

В основном классе программы создаётся AnnotationConfigApplicationContext, служащий контейнером для Spring-бинов.

Далее:
Вызывается бин setterInjectedBean2410 и создаётся экземпляр с помощью сеттера, сначала вызывается конструктор без параметров, затем вызывается сеттер для внедрения зависимости.
Вызывается бин constructorInjectedBean2410, и зависимость внедряется через конструктор.

Ожидаемый вывод:
При создании бина через сеттер вызывается конструктор по умолчанию, затем сеттер, что даёт вывод:
"No-arg constructor"
"Setter injection"
При создании бина через конструктор сразу вызывается конструктор с параметром:
"Constructor injection"
Оба бина вызывают метод useService2410(), который выводит:
"Service called"
"Service called"

Основные моменты:

Сеттер-инъекция требует двух этапов: вызов конструктора без параметров и затем вызов метода сеттера.
Конструкторная инъекция внедряет зависимость сразу при создании объекта.

#Solution_TasksSpring

131 views15:29

Java for Beginner

@Autowired

Аннотация @Autowired — это ключевой элемент механизма внедрения зависимостей (Dependency Injection, DI) в Spring Framework. Она позволяет Spring автоматически разрешать и внедрять зависимости между компонентами приложения. Вместо того чтобы вручную создавать экземпляры объектов, Spring сам берёт на себя задачу управления зависимостями.

С помощью @Autowired мы можем внедрять зависимости в конструкторы, методы и поля классов, избегая необходимости вручную управлять созданием объектов и передачей зависимостей. Spring Framework автоматически ищет подходящие бины в своём контейнере и внедряет их в нужные классы.

Типы внедрения с использованием @Autowired

Внедрение через конструктор
Внедрение через поле
Внедрение через сеттеры (методы)

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    private final MessageService messageService;

    // Внедрение зависимости через конструктор
    @Autowired
    public NotificationService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
В этом примере NotificationService использует внедрение зависимости MessageService через конструктор. Аннотация @Autowired сообщает Spring, что необходимо внедрить экземпляр MessageService в конструктор.

2. Внедрение зависимостей через поле
При внедрении через поле, @Autowired аннотирует само поле класса, и Spring автоматически внедряет зависимость напрямую в это поле. Хотя это способ более прост и не требует создания явного конструктора, он может затруднить тестирование, так как для тестов необходимо использовать рефлексию или фреймворки типа Mockito для подмены полей.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    @Autowired
    private MessageService messageService;

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
Здесь зависимость MessageService внедряется напрямую в поле класса NotificationService.

3. Внедрение зависимостей через сеттеры
Внедрение зависимостей через методы-сеттеры предоставляет возможность изменять зависимости после создания объекта. Это полезно, если зависимость может быть изменяема или опциональна.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class NotificationService {

    private MessageService messageService;

    // Внедрение зависимости через сеттер
    @Autowired
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        messageService.sendMessage(message);
    }
}

@Component
public class MessageService {

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }
}
В данном примере Spring внедряет зависимость через метод-сеттер. Этот подход может быть полезен, если зависимость опциональна или должна изменяться во время работы приложения.

#Java #Training #Spring #Autowired

115 views05:29

Java for Beginner

Дополнительные возможности @Autowired

Обязательные и необязательные зависимости
По умолчанию аннотация @Autowired требует, чтобы зависимость была доступна в контейнере Spring. Если подходящий бин не найден, Spring выбрасывает исключение NoSuchBeanDefinitionException. Однако можно сделать зависимость необязательной, используя параметр required=false.

Пример необязательной зависимости

@Component
public class NotificationService {

    private MessageService messageService;

    // Необязательная зависимость
    @Autowired(required = false)
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void sendNotification(String message) {
        if (messageService != null) {
            messageService.sendMessage(message);
        } else {
            System.out.println("MessageService не доступен.");
        }
    }
}
В этом примере, если бин MessageService не доступен, метод sendNotification() корректно обработает отсутствие зависимости.

Циклические зависимости

Циклическая зависимость возникает, когда два или более бина зависят друг от друга, что может привести к проблемам при создании этих объектов. Spring может автоматически разрешать некоторые циклические зависимости при использовании внедрения через сеттеры, но это не рекомендуется, так как нарушает принцип инверсии управления.

Преимущества использования @Autowired

Автоматизация: Spring сам управляет созданием и внедрением зависимостей, что упрощает разработку.
Гибкость: Возможность использовать внедрение через конструкторы, сеттеры или поля, в зависимости от архитектурных предпочтений.
Тестируемость: Внедрение через конструкторы и сеттеры делает классы легче тестируемыми.

#Java #Training #Spring #Autowired

119 views05:29

Java for Beginner

Что выведет код?

public class Task251024_1 {
    public static void main(String[] args) {
        String input = "abc123xyz456";
        String regex = "\\d+";
        String replacement = "#";
        String result = input.replaceAll(regex, replacement);
        System.out.println(result);
    }
}

#Tasks

122 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

21 voters127 views08:48

Java for Beginner

Это чистая правда....🤪😂😂

https://t.me/Java_for_beginner_dev

#Mems

118 views10:39

Java for Beginner

@Qualifier

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

Аннотация @Qualifier используется вместе с @Autowired для уточнения, какой именно бин должен быть внедрён.

Проблема выбора между несколькими бинами

Рассмотрим пример: у нас есть несколько реализаций одного интерфейса, и нам нужно выбрать конкретную реализацию для внедрения. Без использования @Qualifier Spring не сможет автоматически решить, какой бин использовать, и выбросит исключение NoUniqueBeanDefinitionException.

@Component
public class EmailService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Отправка email: " + message);
    }
}

@Component
public class SmsService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Отправка SMS: " + message);
    }
}

@Component
public class NotificationClient {

    @Autowired
    private NotificationService notificationService;

    public void process() {
        notificationService.sendNotification("Привет!");
    }
}
В данном примере NotificationClient не сможет корректно работать, так как Spring не знает, какой бин — EmailService или SmsService — использовать для внедрения.

Использование @Qualifier для решения проблемы

Чтобы указать Spring, какой бин использовать, мы добавляем аннотацию @Qualifier, в которой указываем имя конкретного бина.

@Component
public class EmailService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Отправка email: " + message);
    }
}

@Component
public class SmsService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Отправка SMS: " + message);
    }
}

@Component
public class NotificationClient {

    private final NotificationService notificationService;

    // Указываем, что нужно использовать EmailService
    @Autowired
    public NotificationClient(@Qualifier("emailService") NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void process() {
        notificationService.sendNotification("Привет!");
    }
}
Здесь с помощью @Qualifier("emailService") мы указываем Spring, что для зависимости NotificationService нужно использовать именно бин emailService.

#Java #Training #Spring #Qualifier

110 views13:59

Java for Beginner

Использование @Qualifier на уровне поля

Аннотацию @Qualifier можно использовать не только на уровне конструктора, но и на уровне полей или методов.

Пример с использованием на поле

@Component
public class NotificationClient {

    @Autowired
    @Qualifier("smsService")  // Указываем бин smsService
    private NotificationService notificationService;

    public void process() {
        notificationService.sendNotification("Привет!");
    }
}

Использование @Qualifier с коллекциями

В некоторых случаях может потребоваться внедрить несколько бинов одного типа. Для этого можно использовать коллекции и @Qualifier для выбора конкретных бинов.

Пример с коллекцией бинов

@Component
public class NotificationProcessor {

    private final List<NotificationService> notificationServices;

    @Autowired
     public NotificationProcessor(@Qualifier("emailService") List<NotificationService> notificationServices) {
        this.notificationServices = notificationServices;
    }

    public void processAll(String message) {
        for (NotificationService service : notificationServices) {
            service.sendNotification(message);
        }
    }
}
В этом примере Spring внедрит все бины, реализующие интерфейс NotificationService, в виде списка.

Использование @Qualifier с кастомными именами бинов

Spring автоматически создаёт имя бина, используя имя класса с маленькой буквы. Однако с помощью аннотации @Component можно указать своё имя бина, а затем использовать это имя в @Qualifier.

Пример с кастомным именем бина

@Component("customEmailService")
public class EmailService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Отправка email: " + message);
    }
}

@Component
public class NotificationClient {

    @Autowired
    @Qualifier("customEmailService")  // Указываем кастомное имя бина
    private NotificationService notificationService;

    public void process() {
        notificationService.sendNotification("Привет!");
    }
}

#Java #Training #Spring #Qualifier

101 views13:59

Java for Beginner

Что выведет код?

Задача по Spring. Тема: #Autowired и #Qualifier. Сложность средняя.

Подробный разбор через 30 минут!🫡

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
class Config2510 {
    @Bean
    public Service2510 serviceA() {
        return new ServiceA2510();
    }

    @Bean
    public Service2510 serviceB() {
        return new ServiceB2510();
    }

    @Bean
    public Client2510 client(@Qualifier("serviceA") Service2510 service) {
        return new Client2510(service);
    }
}

interface Service2510 {
    void execute();
}

class ServiceA2510 implements Service2510 {
    public void execute() {
        System.out.println("Service A executed");
    }
}

class ServiceB2510 implements Service2510 {
    public void execute() {
        System.out.println("Service B executed");
    }
}

class Client2510 {
    private Service2510 service;

    @Autowired
    public Client2510(@Qualifier("serviceA") Service2510 service) {
        this.service = service;
    }

    public void run() {
        service.execute();
    }
}

public class Task251024_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config2510.class);
        Client2510 client = context.getBean(Client2510.class);
        client.run();
        context.close();
    }
}