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();
    }
}

#TasksSpring

115 views14:59

Java for Beginner

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

Anonymous Quiz

11%

Ошибка компиляции

33%

Исключение во время выполнения

56%

Service A executed

Service B executed

9 voters105 views15:04

Java for Beginner

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

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

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

Класс Config2510 определяет два бина, реализующих интерфейс Service2510:
serviceA() возвращает экземпляр класса ServiceA2510, который выводит "Service A executed".
serviceB() возвращает экземпляр класса ServiceB2510, который выводит "Service B executed".
Здесь мы сталкиваемся с ситуацией, когда есть два бина одного типа (оба реализуют интерфейс Service2510), что требует от нас использования механизма разрешения неоднозначности.

2. Аннотации @Autowired и @Qualifier

Аннотация @Autowired указывает Spring, что этот конструктор должен быть использован для внедрения зависимости в Client2510. Однако в контексте есть два бина, которые могут быть внедрены. Для разрешения этой неоднозначности используется аннотация @Qualifier("serviceA"), которая указывает на то, что необходимо внедрить именно бин с именем serviceA.

Таким образом, в клиент будет внедрен бин, возвращаемый методом serviceA(), а не serviceB().

3. Класс Client2510

Класс Client2510 имеет конструктор, который использует внедрение через конструктор с помощью аннотации @Autowired. Этот конструктор принимает параметр типа Service2510 и использует аннотацию @Qualifier("serviceA"), что гарантирует, что в поле service будет внедрен бин serviceA.

Метод run() вызывает метод execute() внедренного сервиса, который в нашем случае является экземпляром ServiceA2510.

4. Main-класс

Основной класс программы создает Spring-контекст с использованием класса AnnotationConfigApplicationContext.

Затем:
Через context.getBean(Client2510.class) получаем экземпляр клиента с внедренным сервисом serviceA.
Вызов метода client.run() приводит к выполнению метода execute() из класса ServiceA2510, который выводит в консоль сообщение "Service A executed".
После выполнения закрываем контекст, освобождая все ресурсы.

Ожидаемое поведение:
Аннотация @Qualifier("serviceA") указывает Spring, что нужно внедрить именно бин serviceA, а не serviceB.
Метод run() вызывает serviceA.execute(), выводя "Service A executed".

Основные выводы:

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

#Solution_TasksSpring

126 views15:29

Java for Beginner

Всем доброго субботнего утра!☀️

Сегодня никаких заданий писать не буду, так как большинство их даже не читает, а я трачу изрядное количество личного времени на это😐😉

Давайте просто отдохнем, а я постараюсь подготовить что-то интересное на завтра💪

И кстати, отсутствие обратной связи от Вас, мои уважаемые подписчики, изрядно демотивирует😔, особенно тогда, когда из нашей, и так немногочисленной группы, народ уходит по 5 человек за раз...🤨

На фоне этого вопрос - чего не хватает нашему каналу, чтобы Вы считали его лучшим и исключительным🧐?

На полном серьезе напишите это в комментариях, а я учту это и изо всех сил постараюсь это сделать.

🫡

138 views01:29

Java for Beginner

This media is not supported in your browser

VIEW IN TELEGRAM

Всем доброе утро!🔆

Сегодня в 16:00 по МСК я приглашаю Вас на лайф-кодинг. ✊

Сегодня я постараюсь рассказать Вам, как работают простейшие нейросети и мы напишем элементарный код который нам это продемонстрирует!)😉

Приходите, будет интересно!✌️

141 views04:55

Java for Beginner

Встреча создана - подключаемся!🤌

https://telemost.yandex.ru/j/98297981728791

143 views12:59

Java for Beginner

Пишем свою нейросеть! Подробные разъяснения и примеры кода. Встреча от 27.10.2024

Запись нашей сегодняшней встречи -
YOUTUBE
RUTUBE

Спасибо тем кто смог прийти, за участие и вопросы!💪

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

Смотрите, комментируйте, задавайте вопросы! Обязательно подписывайтесь на ютуб и рутюб каналы!!!

Ссылка на GitHub - https://github.com/Oleborn/NeuronNet

Всем теплого вечера и хорошего настроения! 🫡✌️

146 viewsedited 15:55

Java for Beginner

Контекст Spring: ApplicationContext и BeanFactory

Spring Container

В основе любого приложения на Spring лежит так называемый Spring Container, который управляет жизненным циклом бинов, их созданием, конфигурированием и внедрением зависимостей. Два основных интерфейса, отвечающих за работу контейнера в Spring, — это BeanFactory и ApplicationContext. Они оба обеспечивают возможность создания и управления объектами (бинами), но существуют важные различия в их функциональности и использовании.

Что такое BeanFactory?

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

Ключевые особенности BeanFactory:

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

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

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class BeanFactoryExample {

    public static void main(String[] args) {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));

        MyService myService = (MyService) factory.getBean("myService");
        myService.doSomething();
    }
}
В этом примере XmlBeanFactory загружает конфигурацию из файла beans.xml, который находится в classpath, и затем извлекает бин myService из контейнера.

Что такое ApplicationContext?

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

Ключевые возможности ApplicationContext:

Автоматическое связывание (autowiring): Spring может автоматически внедрять зависимости без необходимости указывать их явно.
Управление жизненным циклом бинов: Поддерживает начальные и финальные методы для бинов, что упрощает настройку.
Международная поддержка (i18n): Позволяет работать с сообщениями, адаптированными под разные языки и регионы.
Поддержка событий: Включает систему публикации и обработки событий внутри приложения.
Интеграция с AOP: Поддерживает аспектно-ориентированное программирование.

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationContextExample {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}
В этом примере ClassPathXmlApplicationContext загружает тот же файл конфигурации, что и в случае с BeanFactory, но предоставляет больше функциональности за счёт работы с ApplicationContext.

#Java #Training #Spring #BeanFactory #ApplicationContext

117 views05:29

Java for Beginner

Основные различия между BeanFactory и ApplicationContext

Инициализация бинов:
BeanFactory: Ленивая инициализация — бины создаются только по запросу.
ApplicationContext: Все синглтоны создаются сразу при запуске контейнера.

Управление событиями:
BeanFactory: Не поддерживает события.
ApplicationContext: Поддерживает публикацию и обработку событий внутри контейнера.

Международная поддержка (i18n):
BeanFactory: Не поддерживает.
ApplicationContext: Поддерживает работу с локализованными сообщениями.

Интеграция с AOP:
BeanFactory: Ограничена в функциональности аспектов.
ApplicationContext: Полностью поддерживает AOP.

Автоматическое связывание (autowiring):
BeanFactory: Требует явной настройки.
ApplicationContext: Поддерживает автосвязывание.

Когда использовать BeanFactory?

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

Когда использовать ApplicationContext?

ApplicationContext следует использовать в большинстве случаев для полноценного веб-приложения или крупного корпоративного приложения. Он предоставляет намного больше функциональности и упрощает разработку сложных систем.

Примеры событий в ApplicationContext

Одна из ключевых возможностей ApplicationContext — это поддержка событий. Вы можете создать собственные события и обработчики для их обработки.

Создадим событие:

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }

    public String toString() {
        return "Мое кастомное событие!";
    }
}

Создадим обработчик:

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {

    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("Получено событие: " + event);
    }
}

Опубликуем событие:

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

@Component
public class EventPublisher {

    @Autowired
    private ApplicationEventPublisher publisher;

    public void publishCustomEvent() {
        CustomEvent event = new CustomEvent(this);
        publisher.publishEvent(event);
    }
}
Таким образом, Spring предоставляет мощный механизм для работы с событиями через ApplicationContext.

#Java #Training #Spring #BeanFactory #ApplicationContext

118 views05:29

Java for Beginner

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

import java.util.*;

public class Task281024 {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("A");
        set.add("B");
        set.add("A");
        set.add(null);
        set.add("C");
        set.add(null);
        
        for (String s : set) {
            System.out.print(s + " ");
        }
    }
}

#Tasks

118 views08:44

Java for Beginner

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

Anonymous Quiz

18 voters120 views08:48

About

Blog

Apps

Platform