Управление объектами в Spring Container

Spring Container — это ядро Spring Framework, которое отвечает за создание, конфигурирование и управление объектами (или бинами) в приложении. Контейнер контролирует всю логику жизненного цикла объектов, включая их создание, связывание зависимостей, инициализацию и уничтожение. Бины конфигурируются с помощью аннотаций, XML или Java-конфигурации, что позволяет управлять ими и их зависимостями через IoC-контейнер.

Spring предоставляет несколько реализаций IoC-контейнеров, основными из которых являются:
BeanFactory — базовый контейнер для управления бинами. Используется редко, так как не поддерживает многие расширенные функции, такие как обработка событий и интернационализация.
ApplicationContext — более функциональная реализация IoC-контейнера, расширяющая возможности BeanFactory. Поддерживает работу с аннотациями, событиями, AOP и многое другое.

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

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

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

Этапы жизненного цикла бина:
Создание бина: Контейнер создает объект бина на основе конфигурации.
Внедрение зависимостей: Контейнер связывает бин с его зависимостями (через конструктор, сеттеры или аннотации).
Инициализация бина: Контейнер вызывает специальные методы инициализации, если они определены (например, методы с аннотацией @PostConstruct).
Использование бина: Приложение использует бин для выполнения задач.
Завершение работы: Когда контейнер закрывается, он вызывает методы завершения работы бина, если они указаны (например, аннотация @PreDestroy или метод destroy()).

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class SimpleBean {

    // Конструктор бина
    public SimpleBean() {
        System.out.println("1. Бин SimpleBean создан");
    }

    // Метод, вызываемый после внедрения зависимостей
    @PostConstruct
    public void init() {
        System.out.println("2. Бин SimpleBean инициализирован");
    }

    // Метод, вызываемый перед уничтожением бина
    @PreDestroy
    public void destroy() {
        System.out.println("3. Бин SimpleBean уничтожается");
    }
}

Когда контейнер запускается и создается бин SimpleBean, будут выведены следующие сообщения:

1. Бин SimpleBean создан
2. Бин SimpleBean инициализирован
3. Бин SimpleBean уничтожается

Методы управления жизненным циклом

Spring предоставляет несколько способов управления жизненным циклом бинов:
Методы @PostConstruct и @PreDestroy: Используются для определения инициализации и завершения работы объекта.
Интерфейсы InitializingBean и DisposableBean: Реализуются бином для выполнения действий после создания или перед уничтожением.
XML-конфигурация или аннотации @Bean(initMethod = "init", destroyMethod = "cleanup"): Позволяют указывать методы инициализации и завершения в конфигурации Java или XML.

Пример с интерфейсами InitializingBean и DisposableBean:

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Бин инициализирован через afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Бин уничтожен через destroy");
    }
}

#Java #Training #Spring #Spring_Container

Скоупы (Scopes) бинов

В Spring у бинов есть различные области видимости (скоупы), которые определяют, как и когда создаются экземпляры бинов. Основные скоупы включают:
singleton (по умолчанию): Один и тот же экземпляр бина создается и используется для всего контейнера.
prototype: Каждый раз создается новый экземпляр бина при обращении к нему.
request: Новый экземпляр создается для каждого HTTP-запроса. Используется в веб-приложениях.
session: Новый экземпляр создается для каждой HTTP-сессии.
application: Один экземпляр для всего приложения (веб-приложения).
websocket: Создается для каждой WebSocket-сессии.

Пример указания области видимости бина:

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class PrototypeBean {
    public PrototypeBean() {
        System.out.println("Создан новый экземпляр PrototypeBean");
    }
}

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

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

        PrototypeBean bean1 = context.getBean(PrototypeBean.class);
        PrototypeBean bean2 = context.getBean(PrototypeBean.class);

        // Два разных экземпляра
        System.out.println(bean1);
        System.out.println(bean2);
    }
}

Типы контейнеров в Spring

В зависимости от типа приложения и его сложности используются разные реализации контейнеров:
BeanFactory: Базовая версия контейнера. Создает бины лениво, то есть только при первом запросе. В современном Spring используется редко.
ApplicationContext: Расширенная версия контейнера, поддерживающая загрузку бинов сразу при старте. Поддерживает событийную модель, работу с аннотациями, интернационализацию и интеграцию с AOP.

Существует несколько реализаций ApplicationContext:
ClassPathXmlApplicationContext: Загружает конфигурацию бинов из XML-файла, расположенного в classpath.
FileSystemXmlApplicationContext: Загружает конфигурацию из XML-файла, расположенного в файловой системе.
AnnotationConfigApplicationContext: Использует Java-классы для конфигурации бинов.

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

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

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

        SimpleBean bean = context.getBean(SimpleBean.class);
        System.out.println("Бин использован в приложении");
    }
}

#Java #Training #Spring #Spring_Container

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

Задача на #Spring_Container, уровень сложный.

Решение будет опубликовано через 30 минут😉

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

public class Task181024_2 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service1 = context.getBean(MyService.class);
        MyService service2 = context.getBean(MyService.class);
        System.out.println(service1 == service2);
        System.out.println(service1.getDependencyMessage());
    }
}

class MyService {
    private final Dependency dependency;

    public MyService(Dependency dependency) {
        this.dependency = dependency;
    }

    public String getDependencyMessage() {
        return dependency.getMessage();
    }
}

class Dependency {
    private final String message;

    public Dependency(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

@Configuration
class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService(dependency());
    }

    @Bean
    @Scope("prototype")
    public Dependency dependency() {
        return new Dependency("Injected Dependency Message");
    }
}

#TasksSpring