Java for Beginner

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

Spring поддерживает методы для управления жизненным циклом бинов. Можно использовать аннотации @PostConstruct и @PreDestroy, или указать их в XML-конфигурации.

Аннотации @PostConstruct и @PreDestroy:
Добавьте эти методы в классе:

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

@Component
public class LifecycleBean {

    @PostConstruct
    public void init() {
        System.out.println("Bean initialized.");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Bean destroyed.");
    }
}

Вопрос для знатоков:
Почему при запуске этой конфигурации сообщение "Bean destroyed." не выводится в консоль при окончании работы?
Жду ответы в комментариях! И примеры исправленного кода)))

Настройка в XML (если без аннотаций):
В XML можно указать методы:

<bean id="lifecycleBean" class="com.example.LifecycleBean" init-method="init" destroy-method="destroy"/>

6. Dependency Injection через конструктор и сеттеры

Покажите оба подхода на примере классов:
Внедрение через конструктор (уже показано в классе OrderService).

Внедрение через сеттер:
Измените OrderService, чтобы использовать сеттер:

public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Order placed.");
        paymentService.processPayment();
    }
}

7. Паттерны использования бинов

Синглтон уже реализован в пункте 4.
Фабричный метод можно реализовать через бин-фабрику, создавая разные типы объектов на основе логики.
Пример фабрики:

@Component
public class PaymentFactory {
    public PaymentService createPaymentService(String type) {
        if (type.equals("paypal")) {
            return new PayPalService();
        } else {
            return new CreditCardService();
        }
    }
}

#Test_Task_Management

145 views12:01

Java for Beginner

Всем воскресного утра!🔆

Напоминаю, сегодня как и всегда в 16:00 по МСК мы соберемся, чтобы поучиться у @MrAbhorrent писать сложный код!🫡

Давайте придём все и попробуем повторить! 💪

До встречи! ✊

147 views00:53

Java for Beginner

А Вы сделали пробное задание - https://t.me/Java_for_beginner_dev/846? Вам все понравилось?

Anonymous Poll

25%

Да, все отлично, я справился!

13%

Да, но оказалось сложным и непонятным... Нужно больше разъяснений!

Оно слишком легкое для меня))

Нет, мне не понравилось, много непонятного! Нужно больше разъяснений!

Мне просто все не понравилось!

44%

Какое задание?))))))

19%

Я не делал задание, так как некогда было....

16 voters150 views03:07

Java for Beginner

Всем воскресного утра!🔆 Напоминаю, сегодня как и всегда в 16:00 по МСК мы соберемся, чтобы поучиться у @MrAbhorrent писать сложный код!🫡 Давайте придём все и попробуем повторить! 💪 До встречи! ✊

Ребят!) накладочка вышла, сегодня у Андрея не получается никак((( 🫤

Если есть желающие что-то полайкодить - милости прошу)👍

145 views08:56

Java for Beginner

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

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

XML-конфигурация — это способ описания бинов и зависимостей вашего приложения в виде отдельного XML-файла. Контейнер Spring считывает этот файл при старте приложения и создает бины в соответствии с описанной конфигурацией. Основное преимущество XML-конфигурации — это четкое разделение конфигурации от кода.

Основные элементы XML-конфигурации включают:
<beans> — корневой элемент, содержащий все бины и их зависимости.
<bean> — элемент, описывающий бин (объект).
<property> — элемент, задающий свойства бина и внедрение зависимостей.

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

Рассмотрим базовый пример конфигурации Spring-приложения через XML. Допустим, у нас есть простое приложение для отправки сообщений, в котором MessageService отправляет сообщение, а MessageProcessor обрабатывает это сообщение.

1. Определение классов в Java

Создадим два класса: один для обработки сообщений, другой — для отправки.

public interface MessageService {
    void sendMessage(String message);
}

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

public class MessageProcessor {
    private MessageService messageService;

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

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

2. Конфигурация XML

Теперь создадим XML-файл конфигурации, в котором мы опишем бины для классов EmailService и MessageProcessor, а также укажем зависимость.

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!-- Определение бина для сервиса отправки сообщений -->
    <bean id="emailService" class="com.example.EmailService"/>

    <!-- Определение бина для процессора сообщений с внедрением зависимости -->
    <bean id="messageProcessor" class="com.example.MessageProcessor">
        <property name="messageService" ref="emailService"/>
    </bean>
</beans>
Как это работает?
<bean id="emailService">: здесь определяется бин для класса EmailService. Контейнер Spring создаст объект этого класса при запуске.
<bean id="messageProcessor">: бин для MessageProcessor, в котором указана зависимость messageService. С помощью элемента <property> контейнер внедрит объект EmailService в MessageProcessor.

3. Запуск приложения

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

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

public class MainApp {
    public static void main(String[] args) {
        // Загрузка XML-конфигурации
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        // Получение бина messageProcessor
        MessageProcessor processor = (MessageProcessor) context.getBean("messageProcessor");

        // Использование бина
        processor.processMessage("Привет, Spring!");
    }
}

#Java #Training #Spring #Spring_Configuration_XML

124 views05:39

Java for Beginner

Особенности конфигурации через XML

Внедрение зависимостей через конструктор
Spring также поддерживает внедрение зависимостей через конструктор в XML-конфигурации. Для этого используется элемент <constructor-arg>.

<bean id="emailService" class="com.example.EmailService"/>

<bean id="messageProcessor" class="com.example.MessageProcessor">
    <constructor-arg ref="emailService"/>
</bean>
В данном случае зависимость будет передана через конструктор класса MessageProcessor.

Использование коллекций в конфигурации
Spring позволяет передавать коллекции (списки, карты, множества) через XML-конфигурацию:

<bean id="listBean" class="java.util.ArrayList">
    <constructor-arg>
        <list>
            <value>Item 1</value>
            <value>Item 2</value>
        </list>
    </constructor-arg>
</bean>

Определение скоупов бинов
Скоуп бина можно задать через атрибут scope:

<bean id="emailService" class="com.example.EmailService" scope="prototype"/>
singleton (по умолчанию) — один и тот же бин создается для всего приложения.
prototype — новый экземпляр бина создается каждый раз при обращении.

Преимущества и недостатки конфигурации через XML

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

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

Когда использовать XML-конфигурацию?

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

#Java #Training #Spring #Spring_Configuration_XML

112 views05:39

Java for Beginner

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

import java.util.*;

public class Task211024_1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
        list.removeIf(s -> s.startsWith("b"));
        list.replaceAll(String::toUpperCase);
        System.out.println(list);
    }
}

#Tasks

126 views08:44

Java for Beginner

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

Anonymous Quiz

11%

[apple, banana, ORANGE]

84%

[APPLE, ORANGE]

[banana, orange, APPLE]

[apple, ORANGE]

[apple, java, SPRING]

19 voters124 views08:48

Java for Beginner

🧐 а Вы согласны?

https://t.me/Java_for_beginner_dev

#Mems

116 views10:09

Java for Beginner

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

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

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

Основные аннотации, используемые в Spring, включают:
@Component — определяет класс как Spring-бин.
@Autowired — внедряет зависимость в бин.
@Configuration — определяет класс как конфигурационный.
@Bean — указывает метод, возвращающий бин.
@Scope — задает область видимости бина.

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

Рассмотрим пример приложения для отправки сообщений с использованием аннотаций.

1. Определение классов

Создадим интерфейс MessageService и его реализацию EmailService. Затем создадим класс MessageProcessor, который будет зависеть от MessageService.

import org.springframework.stereotype.Component;

public interface MessageService {
    void sendMessage(String message);
}

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

@Component
public class MessageProcessor {

    private final MessageService messageService;

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

    public void processMessage(String message) {
        messageService.sendMessage(message);
    }
}
@Component над классом EmailService и MessageProcessor указывает Spring, что эти классы должны быть зарегистрированы как бины.

2. Автоматическое внедрение зависимостей с @Autowired

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

@Component
public class MessageProcessor {

    private MessageService messageService;

    @Autowired
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage(String message) {
        messageService.sendMessage(message);
    }
}
В этом примере Spring автоматически найдет бин типа MessageService и внедрит его в метод setMessageService.

3. Конфигурация с помощью @Configuration и @Bean

Для более гибкой настройки бинов можно использовать аннотацию @Configuration, которая заменяет XML-конфигурацию на Java-класс.

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

@Configuration
public class AppConfig {

    @Bean
    public MessageService emailService() {
        return new EmailService();
    }

    @Bean
    public MessageProcessor messageProcessor() {
        return new MessageProcessor(emailService());
    }
}
@Configuration указывает, что класс содержит методы для создания бинов.
@Bean указывает метод, который возвращает бин для использования в контейнере Spring.

Запуск приложения

Чтобы запустить приложение с аннотационной конфигурацией, нужно создать ApplicationContext, используя AnnotationConfigApplicationContext.

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

        MessageProcessor processor = context.getBean(MessageProcessor.class);
        processor.processMessage("Привет, Spring с аннотациями!");
    }
}

#Java #Training #Spring #Spring_Configuration_Annotations

120 views13:59

Java for Beginner

Преимущества аннотационной конфигурации

Чистота кода: Конфигурация находится непосредственно в коде, что упрощает поддержку и понимание структуры приложения.
Меньше кода: Отсутствие необходимости создавать отдельные XML-файлы для описания бинов.
Гибкость: Аннотации позволяют использовать все возможности Spring, такие как автоматическое управление зависимостями, скоупами и жизненным циклом бинов.
Лучшая интеграция с современными подходами: Аннотации легко интегрируются с другими фреймворками и библиотеками.

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

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

@Component
public class MessageProcessor {

    private final MessageService messageService;

    @Autowired
    public MessageProcessor(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage(String message) {
        messageService.sendMessage(message);
    }
}
В данном случае мы используем конструктор с аннотацией @Autowired, который внедряет зависимость MessageService.

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

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

@Component
@Qualifier("emailService")
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Отправка Email: " + message);
    }
}

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

@Component
public class MessageProcessor {

    private MessageService messageService;

    @Autowired
    @Qualifier("smsService")
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage(String message) {
        messageService.sendMessage(message);
    }
}
В этом примере, несмотря на наличие нескольких реализаций интерфейса MessageService, с помощью @Qualifier мы указываем, что нужно использовать SmsService.

Определение скоупов через @Scope

Аннотация @Scope позволяет указать область видимости бина. По умолчанию бины создаются с областью видимости singleton, но можно указать другие области, например, prototype.

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

@Component
@Scope("prototype")
public class PrototypeBean {
    public PrototypeBean() {
        System.out.println("Создан новый экземпляр PrototypeBean");
    }
}
Теперь при каждом запросе этого бина Spring будет создавать новый экземпляр.

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

Преимущества:
Простота и удобство: Конфигурация через аннотации делает код более понятным и чистым.
Гибкость: Возможность управлять бинами и зависимостями прямо в коде.
Снижение объема конфигураций: Отсутствие необходимости в громоздких XML-файлах.
Легкость тестирования: Аннотации позволяют легко подменять зависимости в тестах.

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

#Java #Training #Spring #Spring_Configuration_Annotations

93 views13:59

Java for Beginner

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

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

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

import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Value;

public class Task211024_2 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfigTask.class);
        MyServiceTest myService = context.getBean(MyServiceTest.class);
        myService.printMessage();
    }
}

@Component
class MyServiceTest {
    private final MyRepository myRepository;
    private final String prefix;

    public MyServiceTest(MyRepository myRepository, @Value("CustomPrefix") String prefix) {
        this.myRepository = myRepository;
        this.prefix = prefix;
    }

    public void printMessage() {
        System.out.println(prefix + ": " + myRepository.getData());
    }
}

@Component
class MyRepository {
    public String getData() {
        return "Repository Data";
    }
}

@Configuration
@ComponentScan()
class AppConfigTask {}

#TasksSpring

101 views14:59

Java for Beginner

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

Anonymous Quiz

89%

CustomPrefix: Repository Data

11%

NullPointerException

: Repository Data

NoSuchBeanDefinitionException

9 voters106 views15:04

Java for Beginner

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

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

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

2. Конфигурационный класс AppConfigTask:

Класс AppConfigTask помечен аннотацией @Configuration, что говорит Spring о том, что этот класс содержит определения бинов или конфигурацию для приложения.
Аннотация @ComponentScan() указывает, что Spring должен сканировать текущий пакет по умолчанию на наличие компонентов с аннотацией @Component и создавать для них бины.

3. Класс MyServiceTest:

Класс помечен аннотацией @Component, поэтому Spring создаст бин для этого класса.
В конструкторе MyServiceTest происходит автоматическая инъекция зависимости через параметр MyRepository myRepository, что значит, что Spring найдет бин типа MyRepository и передаст его в конструктор.
Также в конструкторе используется аннотация @Value("CustomPrefix"), которая указывает Spring на необходимость подставить строку "CustomPrefix" в поле prefix. Это статическое значение, жестко заданное в коде, а не загружаемое из файла конфигурации.

4. Класс MyRepository:

Этот класс также помечен аннотацией @Component, поэтому Spring создает его бин.
Метод getData() возвращает строку "Repository Data".

5. Работа программы:

После создания контекста в методе main происходит получение бина MyServiceTest через вызов context.getBean(MyService.class).
Затем вызывается метод printMessage() у объекта MyServiceTest
Внутри метода printMessage() выводится в консоль значение переменной prefix и результат вызова метода getData() у объекта myRepository. Значение переменной prefix задается через аннотацию @Value и равно "CustomPrefix". Метод getData() возвращает строку "Repository Data".
Соответственно, в консоли будет выведена строка "CustomPrefix: Repository Data".

Почему это работает?

Spring находит классы MyServiceTest и MyRepository благодаря аннотации @Component и создает для них бины.
Зависимость MyRepository инъектируется в MyServiceTest через конструктор, благодаря автоматической инъекции.
Аннотация @Value("CustomPrefix") указывает на строку, которая напрямую передается в переменную prefix, обеспечивая статическое значение без необходимости внешнего конфигурационного файла.
Результат выводится с правильным форматом: значение из prefix и значение из метода getData().

#Solution_TasksSpring

103 views15:29

Java for Beginner

Основы Bean в Spring: создание и управление

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

Основные компоненты, связанные с бинами в Spring:

Контейнер IoC: это ядро Spring, которое отвечает за создание и управление жизненным циклом бинов.
Конфигурация: способы описания бинов, которые могут быть как в виде XML-файлов, так и с использованием аннотаций или Java-конфигурации.
Внедрение зависимостей (Dependency Injection): механизм, при котором контейнер автоматически предоставляет объектам необходимые зависимости.

Способы создания бинов в Spring

Есть несколько способов создания и определения бинов в Spring:
Создание бина через XML-конфигурацию
Создание бина с помощью аннотаций

Java-классы для конфигурации бинов

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

Пример: создадим простое приложение для отправки сообщений.

public interface MessageService {
    void sendMessage(String message);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Отправка сообщения через Email: " + message);
    }
}

XML-конфигурация (beans.xml):

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!-- Определение бина для EmailService -->
    <bean id="emailService" class="com.example.EmailService"/>
</beans>

Использование бина:

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

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

        MessageService service = (MessageService) context.getBean("emailService");
        service.sendMessage("Привет, Spring!");
    }
}

2. Определение бина с помощью аннотаций

Современный и популярный способ создания бинов в Spring — это использование аннотаций. Аннотации позволяют конфигурировать бины непосредственно в коде, избавляя от необходимости создания XML-файлов.

import org.springframework.stereotype.Component;

@Component
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Отправка сообщения через Email: " + message);
    }
}
Здесь мы используем аннотацию @Component, чтобы 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);

        MessageService service = context.getBean(EmailService.class);
        service.sendMessage("Привет, Spring с аннотациями!");
    }
}

#Java #Training #Spring #Spring_Bean

96 views05:29

Java for Beginner

3. Определение бина через Java-конфигурацию

Другой мощный способ — это использование конфигурационных классов. Аннотация @Configuration позволяет заменить XML-файл Java-классом, в котором объявлены методы с аннотацией @Bean.

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

@Configuration
public class AppConfig {

    @Bean
    public MessageService emailService() {
        return new EmailService();
    }
}
Этот Java-класс полностью заменяет XML-конфигурацию.

Управление бинами в Spring

После того, как бины созданы и зарегистрированы в контейнере, Spring предоставляет множество возможностей для управления ими:
Внедрение зависимостей: Spring автоматически разрешает зависимости бинов, используя внедрение через конструктор, сеттеры или поля.
Скоуп бинов (Scopes): Spring поддерживает несколько областей видимости для бинов, которые управляют временем жизни объектов.

Внедрение зависимостей

Spring поддерживает несколько типов внедрения зависимостей:
Через конструктор — наиболее предпочтительный метод.
Через сеттеры — позволяет внедрять зависимости после создания объекта.

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

@Component
public class MessageProcessor {

    private final MessageService messageService;

    @Autowired
    public MessageProcessor(MessageService messageService) {
        this.messageService = messageService;
    }

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

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

@Component
public class MessageProcessor {

    private MessageService messageService;

    @Autowired
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

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

Скоупы бинов

Spring поддерживает следующие основные скоупы для бинов:
Singleton — по умолчанию каждый бин создается в одном экземпляре для всего приложения.
Prototype — новый экземпляр бина создается каждый раз при запросе.

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

@Component
@Scope("prototype")
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Отправка сообщения через Email: " + message);
    }
}

Lazy и Eager инициализация бинов

Spring предоставляет возможность управлять тем, когда именно создаются бины:
Eager инициализация — бины создаются сразу при старте контекста (по умолчанию).
Lazy инициализация — бины создаются только тогда, когда они впервые запрашиваются.

@Component
@Lazy
public class LazyService {
    public LazyService() {
        System.out.println("LazyService создан");
    }
}
В данном случае бин LazyService не будет создан до тех пор, пока он не будет запрошен.

Преимущества управления бинами в Spring

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

#Java #Training #Spring #Spring_Bean

106 views05:29

Java for Beginner

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

public class Task221024_1 {
    public static void main(String[] args) {
        System.out.println(Status.PENDING.getDescription());
        System.out.println(Status.APPROVED.ordinal());
    }
}

enum Status {
    PENDING("Waiting for approval"),
    APPROVED("Approved by admin"),
    REJECTED("Request denied");

    private String description;

    Status(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }
}

#Tasks

112 views08:44

Java for Beginner

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

Anonymous Quiz

Waiting for approval 0

92%

Waiting for approval 1

Approved by admin 1

Request denied 2

Java cool 3

12 voters107 views08:44

Java for Beginner

А потом разработчик виноват😂

https://t.me/Java_for_beginner_dev

#Mems

118 views10:29

Java for Beginner

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

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

Этапы жизненного цикла бина в Spring

Жизненный цикл бина включает в себя несколько стадий:
Создание бина: контейнер IoC создает объект и управляет его инициализацией.
Внедрение зависимостей: если у бина есть зависимости, они автоматически разрешаются и внедряются Spring.
Пост-инициализация: дополнительные операции, которые можно выполнить после создания объекта.
Использование бина: бин может быть использован в приложении.
Уничтожение бина: при завершении работы приложения Spring уничтожает бины.

Жизненный цикл бина на примере

Создадим пример с бином, который отправляет сообщения, и реализуем этапы его жизненного цикла.

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

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

@Component
public class MessageService {

    public MessageService() {
        System.out.println("Создание бина MessageService");
    }

    @PostConstruct
    public void init() {
        System.out.println("Инициализация бина MessageService");
    }

    public void sendMessage(String message) {
        System.out.println("Отправка сообщения: " + message);
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Уничтожение бина MessageService");
    }
}

Объяснение этапов:
Конструктор: при создании бина вызывается конструктор класса. Здесь мы видим, что при создании бина выводится сообщение "Создание бина MessageService".
Аннотация @PostConstruct: после создания бина и внедрения всех зависимостей вызывается метод, помеченный этой аннотацией. В нашем примере это метод init(), который выводит сообщение "Инициализация бина MessageService".
Методы бина: после инициализации бин может быть использован для выполнения своих задач. В данном случае это метод sendMessage(), который выводит сообщение.
Аннотация @PreDestroy: перед уничтожением бина вызывается метод, помеченный аннотацией @PreDestroy. В нашем примере это метод destroy(), который выводит сообщение "Уничтожение бина MessageService".

Использование интерфейсов для управления жизненным циклом

Spring также предоставляет интерфейсы для более детального управления жизненным циклом бинов:
InitializingBean: интерфейс с методом afterPropertiesSet(), который вызывается после внедрения зависимостей.
DisposableBean: интерфейс с методом destroy(), который вызывается при завершении работы приложения для уничтожения бина.

Пример реализации этих интерфейсов:

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

@Component
public class CustomService implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Инициализация бина CustomService через afterPropertiesSet");
    }

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

#Java #Training #Spring #Spring_Bean_LifeCicle

120 views13:59

About

Blog

Apps

Platform