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

Жизненный цикл 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

About

Blog

Apps

Platform