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

Java for Beginner

Хорошее сравнение 🤪😂😂😂

https://t.me/Java_for_beginner_dev

#Mems

119 views10:19

Java for Beginner

Способы загрузки контекста в Spring

Загрузка контекста в Spring

Контейнер Spring может загружать конфигурацию приложения из различных источников, таких как XML-файлы, Java-классы и аннотации. Основные способы загрузки контекста включают использование ClassPathXmlApplicationContext, FileSystemXmlApplicationContext, а также более современные подходы с помощью Java-классов и аннотаций.

1. ClassPathXmlApplicationContext

ClassPathXmlApplicationContext загружает конфигурационные файлы из classpath (путь, по которому Java ищет классы и ресурсы). Это удобно для приложений, где конфигурация хранится в ресурсах проекта и должна быть доступна через classpath.

Пример загрузки конфигурации через ClassPathXmlApplicationContext

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

public class ClassPathContextExample {

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

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}
Здесь XML-файл beans.xml должен находиться в директории ресурсов (src/main/resources).

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

2. FileSystemXmlApplicationContext

FileSystemXmlApplicationContext загружает конфигурационные файлы из файловой системы. Это даёт возможность указывать динамические пути к конфигурациям, что полезно, если конфигурация расположена за пределами проекта.

Пример загрузки конфигурации через FileSystemXmlApplicationContext

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

public class FileSystemContextExample {

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

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}

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

3. AnnotationConfigApplicationContext — для конфигурации с помощью аннотаций

AnnotationConfigApplicationContext — это более современный способ загрузки контекста в Spring, основанный на использовании Java-конфигураций и аннотаций. Вместо XML-файлов для конфигурации используются Java-классы с аннотациями, такими как @Configuration, @Bean, и @ComponentScan.

Пример конфигурации через аннотации с использованием AnnotationConfigApplicationContext

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

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

public class AnnotationConfigExample {

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

        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}
В этом примере мы создаём конфигурационный класс AppConfig, помеченный аннотацией @Configuration, и регистрируем метод myService() с помощью аннотации @Bean. AnnotationConfigApplicationContext загружает эту конфигурацию и предоставляет необходимые бины.

Преимущества:
Чистота и компактность конфигурации.
Легче тестировать и поддерживать, так как конфигурация написана на Java.
Хорошо подходит для современных проектов, использующих аннотации.

#Java #Training #Spring #Load_context

102 views14:19

Java for Beginner

4. GenericApplicationContext — для комбинированного использования различных типов конфигурации

GenericApplicationContext — это универсальный контейнер, который можно использовать для объединения различных типов конфигураций, таких как XML и Java-аннотации. Он является гибким и поддерживает комбинированную конфигурацию, когда нужно объединить несколько различных подходов.

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

import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class GenericContextExample {

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();

        // Добавляем конфигурацию через XML
        new ClassPathXmlApplicationContext("beans.xml", context);
        
        // Добавляем конфигурацию через аннотации
        new AnnotationConfigApplicationContext(AppConfig.class);

        context.refresh();

        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}
В этом примере мы объединяем загрузку конфигурации из XML (beans.xml) и Java-аннотаций (AppConfig.class) с помощью GenericApplicationContext. Это мощный способ работы с несколькими типами конфигураций одновременно.

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

Когда использовать каждый способ загрузки контекста?

ClassPathXmlApplicationContext — если конфигурация хранится в ресурсах проекта и должна быть доступна через classpath.
FileSystemXmlApplicationContext — если конфигурационные файлы находятся за пределами приложения и вам нужно динамически указывать путь к ним.
AnnotationConfigApplicationContext — предпочтителен для современных приложений, использующих Java-конфигурации и аннотации.
GenericApplicationContext — идеален для приложений, где требуется объединить различные типы конфигурации (XML, Java-аннотации).

#Java #Training #Spring #Load_context

79 views14:19

Java for Beginner

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

Задача по Spring. Различия между BeanFactory и ApplicationContext. Сложность легкая.

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

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class Task281024_2 {
    public static void main(String[] args) {
        BeanFactory beanFactory = new AnnotationConfigApplicationContext(Config2810.class);
        ApplicationContext appContext = new AnnotationConfigApplicationContext(Config2810.class);

        Bean2810 beanFromFactory = (Bean2810) beanFactory.getBean("bean2810");
        Bean2810 beanFromContext = (Bean2810) appContext.getBean("bean2810");

        System.out.println(beanFromFactory == beanFromContext);
    }
}

@Configuration
class Config2810 {
    @Bean
    public Bean2810 bean2810() {
        return new Bean2810();
    }
}

class Bean2810 {}

#TasksSpring

95 views14:59

Java for Beginner

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

Anonymous Quiz

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

Java

7 voters104 views15:04

Java for Beginner

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

1. Контекст задачи:

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

2. Код задачи:

В задаче создаются два разных контейнера Spring:
BeanFactory инициализируется через AnnotationConfigApplicationContext.
ApplicationContext инициализируется через тот же класс AnnotationConfigApplicationContext.
Конфигурационный класс Config2810 предоставляет бин типа Bean2810, который регистрируется в обоих контейнерах.

3. Ключевой момент:

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

В строках:

Bean2810 beanFromFactory = (Bean2810) beanFactory.getBean("bean2810");
Bean2810 beanFromContext = (Bean2810) appContext.getBean("bean2810");
вызывается метод getBean для получения бина из каждого контейнера.

Результат: Проверка на идентичность с помощью оператора == возвращает false, поскольку BeanFactory и ApplicationContext создают разные экземпляры Bean2810.

4. Аннотации и конфигурация:

В этой задаче конфигурация бинов осуществляется с использованием аннотации @Bean, которая указывает Spring создать и управлять бином через указанный метод. Это не требует XML-файлов, что упрощает код, делая его более современным и наглядным.

5. Основные выводы задачи:

BeanFactory vs ApplicationContext: Хотя оба этих контейнера могут управлять бинами, их поведения различаются:
BeanFactory создаёт бины лениво, т.е. при первом запросе через getBean().
ApplicationContext инициализирует бины сразу при запуске контекста.
При использовании одного и того же конфигурационного класса каждый контейнер создаёт свои экземпляры, которые не являются одинаковыми объектами.

#Solution_TasksSpring

95 views15:29

Java for Beginner

Жизненный цикл ApplicationContext в Spring

В основе работы любого приложения Spring лежит контейнер IoC (Inversion of Control), который управляет созданием, конфигурированием и управлением бинов. Контекст приложения (ApplicationContext) — это более продвинутый контейнер по сравнению с BeanFactory, который не только управляет бинами, но и предоставляет множество дополнительных возможностей. Понимание жизненного цикла ApplicationContext — это ключевой элемент при построении приложения с использованием Spring.

1. Что такое ApplicationContext?

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

Пример того, как выглядит структура наследования ApplicationContext:
BeanFactory — базовый интерфейс для управления бинами.

ApplicationContext — расширяет BeanFactory, добавляя такие возможности, как:
Автоматическая регистрация событий;
Интеграция с AOP (Aspect-Oriented Programming);
Поддержка аннотаций.

2. Этапы жизненного цикла ApplicationContext

Жизненный цикл ApplicationContext можно разделить на несколько этапов:

2.1. Создание ApplicationContext

Первым шагом является создание объекта контекста. В зависимости от типа конфигурации вы можете выбрать нужный вам тип контекста, например, ClassPathXmlApplicationContext, AnnotationConfigApplicationContext или FileSystemXmlApplicationContext.

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

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        MyService myService = context.getBean(MyService.class);
        myService.doWork();
    }
}

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

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doWork();
    }
}

2.2. Чтение конфигурации

После создания контекста Spring загружает конфигурацию (XML или Java-классы). В этом процессе Spring сканирует конфигурационные файлы или аннотированные классы и регистрирует бины.

2.3. Создание и инициализация бинов

После загрузки конфигурации и создания контекста, Spring создаёт экземпляры всех бинов и выполняет их инициализацию. Если в классе бин есть метод, помеченный аннотацией @PostConstruct, он будет вызван на этом этапе.

2.4. Внедрение зависимостей (Dependency Injection)

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

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

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

public class MyService {

    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    public void doWork() {
        myRepository.saveData();
    }
}

#Java #Training #Spring #ApplicationContext_LifeCicle

97 views05:29

Java for Beginner

2.5. Готовность к работе

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

2.6. Закрытие контекста

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

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

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

public class App {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doWork();

        // Закрытие контекста вручную
        context.close();
    }
}

2.7. Уничтожение бинов

На этапе закрытия контекста Spring вызывает методы разрушения (destroy methods) бинов, если они определены, чтобы гарантировать освобождение ресурсов, таких как соединения с базами данных или потоки.

3. События в жизненном цикле ApplicationContext

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

Это:
ContextRefreshedEvent — событие генерируется после того, как все бины были инициализированы и контекст готов к работе.
ContextClosedEvent — генерируется при закрытии контекста.
ContextStartedEvent и ContextStoppedEvent — для запуска и остановки контекста.

Пример слушателя событий:

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

@Component
public class ContextStartedListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("Контекст был обновлён и готов к использованию.");
    }
}

#Java #Training #Spring #ApplicationContext_LifeCicle

106 views05:29

Java for Beginner

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

public class Task291024_1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 5;
        int result = (a + b) * c / 2;
        System.out.println("Result: " + result);
    }
}

#Tasks

113 viewsedited 08:44

About

Blog

Apps

Platform