Java for Beginner
672 subscribers
541 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Синглтон и Прототипы в Spring

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

Что такое скоуп (Scope) бина?

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


Singleton Scope (Синглтон)

Синглтон — это скоуп по умолчанию в Spring. Когда бин имеет скоуп синглтона, контейнер создает только один его экземпляр для всего приложения. Этот бин будет использоваться повторно при каждом обращении к нему в течение времени работы приложения.


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

Создадим класс, который представляет собой сервис для отправки сообщений:
import org.springframework.stereotype.Component;

@Component
public class MessageService {
public MessageService() {
System.out.println("Создан объект MessageService");
}

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


Теперь создадим приложение, которое использует этот бин несколько раз:

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 дважды
MessageService service1 = context.getBean(MessageService.class);
service1.sendMessage("Привет, Spring!");

MessageService service2 = context.getBean(MessageService.class);
service2.sendMessage("Второе сообщение");

// Проверим, что оба объекта одинаковы
System.out.println(service1 == service2); // true
}
}
В данном случае Spring создает только один экземпляр MessageService, и каждый раз при запросе через context.getBean() возвращается один и тот же объект. Сообщение в консоли "Создан объект MessageService" будет выведено только один раз.


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

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

Примеры:
Сервисы, которые обеспечивают кэширование данных.
Сервисы для доступа к базе данных, где создаётся пул соединений.
Управляющие объекты, которые контролируют общий процесс приложения.


#Java #Training #Spring #Spring_Singleton
Prototype Scope (Прототип)

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

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


Для того чтобы использовать прототипный скоуп, нужно явно указать его с помощью аннотации @Scope("prototype").
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

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

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


Теперь создадим приложение, которое несколько раз запрашивает бин:

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 дважды
MessageService service1 = context.getBean(MessageService.class);
service1.sendMessage("Привет, Spring!");

MessageService service2 = context.getBean(MessageService.class);
service2.sendMessage("Второе сообщение");

// Проверим, что оба объекта разные
System.out.println(service1 == service2); // false
}
}
В этом случае Spring создает новый экземпляр MessageService каждый раз при вызове context.getBean(). Вывод в консоли будет включать два сообщения "Создан новый экземпляр MessageService", указывающие на то, что создаются два разных объекта.


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

Прототипы полезны, когда требуется создание множества независимых экземпляров бинов. Примеры использования:
Управление состоянием объектов, которые используются в короткоживущих процессах (например, сеансы).
Логика работы с временными данными, которые не должны храниться на протяжении всего времени работы приложения.
Бины, которые выполняют действия с коротким сроком жизни, такие как задачи по обработке данных.


Взаимодействие с Singleton и Prototype

Одной из задач, с которой могут столкнуться разработчики, является внедрение бинов с прототипным скоупом в бин с синглтон-синглтон скоупом. Проблема здесь в том, что синглтон создается один раз, и если вы внедряете в него прототипный бин, то этот прототип будет создан лишь один раз, даже если его скоуп предполагает создание новых объектов при каждом запросе.

Для решения этой задачи используется внедрение прототипа через ObjectFactory или Provider.

Пример с использованием ObjectFactory
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Lookup;
import org.springframework.stereotype.Component;

@Component
public class SingletonService {

@Autowired
private ObjectFactory<MessageService> messageServiceFactory;

public void processMessage(String message) {
MessageService messageService = messageServiceFactory.getObject();
messageService.sendMessage(message);
}
}
Здесь метод messageServiceFactory.getObject() создает новый экземпляр MessageService каждый раз, когда вызывается метод processMessage().


#Java #Training #Spring #Spring_Prototype
Что выведет код?

public class Task231024_1 {
public static void main(String[] args) {
int i = 5;
while (i-- > 0) {
if (i == 2) {
continue;
}
System.out.print(i + " ");
}
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
9%
4 3 2 1 0
9%
4 3 1 0 -1
68%
4 3 1 0
14%
3 1 0 -1
0%
127.0.0.1
И откуда появляется паранойя? 🧐🤪😂

https://t.me/Java_for_beginner_dev

#Mems
Паттерны использования бинов в Spring

Spring предлагает гибкую и мощную инфраструктуру для создания и управления бинами. Благодаря использованию различных паттернов проектирования, таких как Factory, Service Locator, Dependency Injection, разработчики могут строить приложения, которые легко поддерживать и расширять.

1. Паттерн Factory (Фабрика)

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

Пример фабрики в Spring

Создадим фабрику, которая будет возвращать объекты MessageService с различными типами отправки сообщений:
public class MessageServiceFactory {

public static MessageService createMessageService(String type) {
if ("email".equalsIgnoreCase(type)) {
return new EmailService();
} else if ("sms".equalsIgnoreCase(type)) {
return new SmsService();
}
throw new IllegalArgumentException("Неизвестный тип сервиса: " + type);
}
}


Использование фабрики в Spring:

<bean id="messageService" class="com.example.MessageServiceFactory" factory-method="createMessageService">
<constructor-arg value="email"/>
</bean>
В этом примере бин MessageService создается с помощью фабрики, и мы можем легко изменять его тип без необходимости изменения основного кода.


2. Паттерн Service Locator (Локатор Сервисов)

Service Locator — это паттерн, который позволяет получить необходимые зависимости через централизованный компонент. В Spring этот паттерн реализуется через ApplicationContext, который предоставляет методы для получения бинов по их типу или имени.

Пример Service Locator
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ServiceLocatorExample {

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

// Получаем бин по его типу
MessageService service = context.getBean(MessageService.class);
service.sendMessage("Сообщение через Service Locator");
}
}
Паттерн Service Locator хорош, когда необходимо динамически получать зависимости, но следует быть осторожным, чтобы не злоупотреблять этим паттерном, так как он может нарушить принципы инверсии управления.


3. Паттерн Dependency Injection (Внедрение Зависимостей)

Dependency Injection (DI) — это основной паттерн, на котором строится Spring. Он позволяет передавать зависимости объекту через конструктор, сеттеры или интерфейсы. Внедрение зависимостей способствует слабой связанности кода, что упрощает его тестирование и сопровождение.

Пример внедрения через конструктор
@Component
public class MessageService {
private final NotificationService notificationService;

@Autowired
public MessageService(NotificationService notificationService) {
this.notificationService = notificationService;
}

public void sendMessage(String message) {
notificationService.notify(message);
}
}
Здесь зависимость NotificationService внедряется в конструктор класса MessageService.


Пример внедрения через сеттер
@Component
public class MessageService {
private NotificationService notificationService;

@Autowired
public void setNotificationService(NotificationService notificationService) {
this.notificationService = notificationService;
}

public void sendMessage(String message) {
notificationService.notify(message);
}
}


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

#Java #Training #Spring #Spring_Patterns
4. Паттерн Proxy (Заместитель)

Паттерн Proxy используется для управления доступом к объекту или для добавления дополнительной логики перед вызовом методов.

Пример использования Proxy через AOP

Spring AOP позволяет легко внедрять кросс-каттинговые (перекрёстные) задачи, такие как логирование, безопасность, или управление транзакциями.
@Aspect
@Component
public class LoggingAspect {

@Before("execution(* com.example.service.*.*(..))")
public void logBeforeMethod(JoinPoint joinPoint) {
System.out.println("Вызов метода: " + joinPoint.getSignature().getName());
}
}
Здесь мы создаём аспект (Aspect), который использует прокси для добавления логирования перед вызовом любого метода в указанном пакете.


5. Паттерн Template Method (Шаблонный Метод)

Template Method позволяет определять алгоритм в суперклассе, оставляя определённые шаги для реализации в подклассах. В Spring этот паттерн реализован в различных helper-классах, например, JdbcTemplate, RestTemplate, где основная логика выполнения операции обобщена.

Пример использования JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;

public void addUser(String name, int age) {
String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
jdbcTemplate.update(sql, name, age);
}
Здесь JdbcTemplate инкапсулирует шаблонный метод для выполнения SQL-запросов, а детали (вроде обработки исключений или управления транзакциями) обрабатываются внутри JdbcTemplate.


8. Паттерн Observer (Наблюдатель)

Паттерн Observer (Наблюдатель) используется для реализации механизма подписки-уведомления, где один объект (Subject) уведомляет множество наблюдателей (Observers) о событиях. В Spring этот паттерн реализован через события (Event), которые могут быть опубликованы и обработаны компонентами.

Пример реализации событий в Spring
// Определение события
public class UserCreatedEvent extends ApplicationEvent {
private String username;

public UserCreatedEvent(Object source, String username) {
super(source);
this.username = username;
}

public String getUsername() {
return username;
}
}

// Публикация события
@Component
public class UserService {

@Autowired
private ApplicationEventPublisher eventPublisher;

public void createUser(String username) {
System.out.println("Создание пользователя: " + username);
eventPublisher.publishEvent(new UserCreatedEvent(this, username));
}
}

// Обработчик события
@Component
public class UserEventListener {

@EventListener
public void handleUserCreated(UserCreatedEvent event) {
System.out.println("Пользователь создан: " + event.getUsername());
}
}
Здесь UserService публикует событие UserCreatedEvent, которое обрабатывается компонентом UserEventListener.


7. Паттерн Strategy (Стратегия)

Паттерн Strategy позволяет определять семейство алгоритмов, инкапсулировать их и сделать их взаимозаменяемыми. В Spring этот паттерн часто используется через внедрение зависимостей, где определённая стратегия передаётся в виде бина.

Пример реализации паттерна Strategy
public interface NotificationStrategy {
void send(String message);
}

@Component
public class EmailNotification implements NotificationStrategy {
public void send(String message) {
System.out.println("Отправка email: " + message);
}
}

@Component
public class SmsNotification implements NotificationStrategy {
public void send(String message) {
System.out.println("Отправка SMS: " + message);
}
}

@Component
public class NotificationService {

private final NotificationStrategy notificationStrategy;

@Autowired
public NotificationService(NotificationStrategy notificationStrategy) {
this.notificationStrategy = notificationStrategy;
}

public void sendNotification(String message) {
notificationStrategy.send(message);
}
}
В этом примере стратегия уведомлений может быть легко изменена путем внедрения различных реализаций интерфейса NotificationStrategy.


#Java #Training #Spring #Spring_Patterns
Что выведет код?

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

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

import org.springframework.context.annotation.*;

@Configuration
class Config {
@Bean
@Scope("singleton")
public MyBean2310 singletonBean() {
return new MyBean2310("singleton");
}

@Bean
@Scope("prototype")
public MyBean2310 prototypeBean() {
return new MyBean2310("prototype");
}
}

class MyBean2310 {
public MyBean2310(String scope) {
System.out.println("MyBean created for "+scope);
}
}

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

MyBean2310 singleton1 = context.getBean("singletonBean", MyBean2310.class);
MyBean2310 singleton2 = context.getBean("singletonBean", MyBean2310.class);

MyBean2310 prototype1 = context.getBean("prototypeBean", MyBean2310.class);
MyBean2310 prototype2 = context.getBean("prototypeBean", MyBean2310.class);

context.close();
}
}


#TasksSpring
Подробный разбор решения задачи Task231024_2

В этой задаче мы изучаем различия между синглтон (singleton) и прототип (prototype) бинами в контексте Spring Framework. Важно понять, как Spring управляет объектами с разными жизненными циклами (scopes) и сколько экземпляров класса создается в зависимости от области действия бина.

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

Класс Config содержит два бина:
singletonBean() возвращает объект класса MyBean2310 с областью действия singleton.
prototypeBean() возвращает объект того же класса, но с областью действия prototype.


Ключевые аннотации:
@Configuration: указывает на класс, содержащий определение бинов.
@Bean: создает и управляет объектом бина.
@Scope: указывает на область действия бина — singleton или prototype.

2. Класс MyBean2310

В конструкторе этого класса есть строковый параметр scope, который показывает, для какого типа области действия (singleton или prototype) создается объект. При создании объекта этот параметр передается, и выводится сообщение "MyBean created for <scope>".

3. Main-класс

Основной класс программы создает AnnotationConfigApplicationContext, который служит контейнером для Spring-менеджера бинов.

Здесь выполняются следующие действия:

Запрашивается бин singletonBean дважды: оба раза возвращается один и тот же экземпляр.
Запрашивается бин prototypeBean дважды: каждый раз создается новый экземпляр.


4. Ожидаемое поведение

Синглтон-область действия (singleton scope):
Spring создает только один экземпляр бина с областью действия singleton, и этот объект используется во всех запросах к контейнеру.
Вызовы getBean("singletonBean") возвращают один и тот же объект.


Прототип-область действия (prototype scope):
Каждый вызов getBean("prototypeBean") создает новый экземпляр бина, то есть при каждом запросе контейнер создает новый объект.

Пояснение вывода в консоль:
Первая строка выводится при первом вызове context.getBean("singletonBean"). Поскольку бин имеет область синглтон, этот же объект будет возвращаться при каждом последующем запросе, и повторного создания объекта не произойдет.
Вторая строка появляется при первом вызове context.getBean("prototypeBean"), где создается новый экземпляр прототипа.
Третья строка появляется при втором вызове context.getBean("prototypeBean"), где создается еще один новый экземпляр для прототипа.


Основные выводы:
Синглтон-бин создается один раз при первом запросе, и тот же экземпляр используется во всех последующих вызовах.
Прототип-бин создается каждый раз при запросе контейнера, то есть каждый вызов getBean() создает новый объект.


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

Введение в концепцию Dependency Injection (DI)

Dependency Injection (DI) — это один из основных принципов разработки программного обеспечения, основанный на инверсии управления. Этот принцип позволяет классу не создавать свои зависимости самостоятельно, а получать их извне, обычно через конструктор, сеттеры или интерфейсы. DI способствует слабой связанности компонентов и улучшает тестируемость кода.


Spring Framework построен на основе DI, что делает его важным аспектом для понимания того, как работает этот фреймворк. Внедрение зависимостей через конструктор — это один из самых распространённых и рекомендуемых подходов, так как он позволяет создавать неизменяемые объекты и упрощает тестирование.

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

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

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

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

Допустим, у нас есть класс NotificationService, который зависит от другого класса MessageService. Вот как можно использовать внедрение через конструктор:
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 в этот конструктор.


#Java #Training #Spring #Dependency_Injection_via_constructor
Конфигурация с использованием аннотаций

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

Создадим основной класс приложения, где 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);

// Получаем бин NotificationService
NotificationService notificationService = context.getBean(NotificationService.class);

// Используем сервис для отправки уведомления
notificationService.sendNotification("Привет, Spring!");
}
}


Конфигурация с использованием XML


Кроме аннотаций, Spring также поддерживает конфигурацию бинов через XML-файлы. Вот как можно задать внедрение зависимостей через конструктор в XML-конфигурации:
<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">

<!-- Определение бина MessageService -->
<bean id="messageService" class="com.example.MessageService"/>

<!-- Определение бина NotificationService с внедрением через конструктор -->
<bean id="notificationService" class="com.example.NotificationService">
<constructor-arg ref="messageService"/>
</bean>
</beans>
При такой конфигурации Spring автоматически передаст бин messageService в конструктор бина notificationService.


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

Иммутабельность (неизменяемость): Параметры, переданные через конструктор, становятся неизменными, что улучшает безопасность кода.
Явная зависимость: Использование конструктора делает зависимости явными, так как при создании объекта сразу видно, какие зависимости необходимы для его работы.
Тестируемость: Классы, которые используют внедрение через конструктор, проще тестировать с помощью Mock-объектов (например, с помощью фреймворков Mockito или JUnit), поскольку зависимости можно легко передать в тестах.
Невозможность создания "полуинициализированных" объектов: Все зависимости обязательно передаются в момент создания объекта, что исключает возможность использования объекта без всех необходимых ресурсов.


Когда использовать внедрение через конструктор?

Необходимые зависимости: Когда зависимость обязательна для работы класса, её лучше передавать через конструктор. Это гарантирует, что объект не может быть создан без необходимых зависимостей.
Неизменяемые объекты: Если объект не должен изменяться после создания (например, если его состояние зависит от переданных параметров), лучше использовать конструктор для передачи зависимостей.


#Java #Training #Spring #Dependency_Injection_via_constructor
Что выведет код?

public class Task241024_1 {
public static void main(String[] args) {
int a = 5;
int b = a++ + --a + a-- + ++a;
System.out.println(b);
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
6%
5
12%
10
18%
19
65%
20
0%
186
А какие мысли приходят к Вам после 3:00? 🤪🧐😂😂

https://t.me/Java_for_beginner_dev

#Mems
Spring. Внедрение зависимостей через сеттеры

Что такое внедрение зависимостей через сеттеры?

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

Spring поддерживает автоматическое внедрение зависимостей через сеттеры с использованием аннотации @Autowired на уровне метода-сеттера или с помощью XML-конфигурации.

Пример внедрения через сеттеры

Давайте рассмотрим пример, где тот же класс NotificationService использует внедрение зависимости через сеттер:
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);
}
}
Здесь MessageService внедряется через метод-сеттер setMessageService() с использованием аннотации @Autowired. В отличие от внедрения через конструктор, здесь зависимость может быть изменена в любое время после создания объекта.



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


Если вам необходимо использовать XML-конфигурацию для внедрения зависимости через сеттеры, это можно сделать так:
<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">

<!-- Определение бина MessageService -->
<bean id="messageService" class="com.example.MessageService"/>

<!-- Определение бина NotificationService с внедрением через сеттер -->
<bean id="notificationService" class="com.example.NotificationService">
<property name="messageService" ref="messageService"/>
</bean>
</beans>
В этом случае Spring вызовет сеттер setMessageService() и передаст бин messageService в качестве зависимости.


#Java #Training #Spring #Dependency_Injection_via_setters
Преимущества и недостатки внедрения через сеттеры

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


Недостатки:
Возможность "полуинициализированного" объекта: Так как зависимости могут быть переданы после создания объекта, существует риск того, что объект может быть использован до того, как все зависимости будут установлены.
Явная зависимость менее очевидна: В отличие от внедрения через конструктор, где зависимости видны при создании объекта, здесь необходимо знать, что сеттеры должны быть вызваны после создания объекта, что может быть не так очевидно.


Когда использовать внедрение через сеттеры?

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


Сравнение внедрения через конструктор и через сеттеры

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



#Java #Training #Spring #Dependency_Injection_via_setters
Что выведет код?

Задача по 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
Подробный разбор решения задачи 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
@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