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
А какие мысли приходят к Вам после 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
Дополнительные возможности @Autowired

Обязательные и необязательные зависимости

По умолчанию аннотация @Autowired требует, чтобы зависимость была доступна в контейнере Spring. Если подходящий бин не найден, Spring выбрасывает исключение NoSuchBeanDefinitionException. Однако можно сделать зависимость необязательной, используя параметр required=false.

Пример необязательной зависимости
@Component
public class NotificationService {

private MessageService messageService;

// Необязательная зависимость
@Autowired(required = false)
public void setMessageService(MessageService messageService) {
this.messageService = messageService;
}

public void sendNotification(String message) {
if (messageService != null) {
messageService.sendMessage(message);
} else {
System.out.println("MessageService не доступен.");
}
}
}
В этом примере, если бин MessageService не доступен, метод sendNotification() корректно обработает отсутствие зависимости.


Циклические зависимости

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

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

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


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

public class Task251024_1 {
public static void main(String[] args) {
String input = "abc123xyz456";
String regex = "\\d+";
String replacement = "#";
String result = input.replaceAll(regex, replacement);
System.out.println(result);
}
}


#Tasks
Это чистая правда....🤪😂😂

https://t.me/Java_for_beginner_dev

#Mems
@Qualifier

В Spring может возникнуть ситуация, когда в контейнере существует несколько бинов одного типа, и Spring не знает, какой из них использовать для внедрения зависимости. Чтобы разрешить эту проблему, используется аннотация
@Qualifier, которая помогает точно указать, какой бин необходимо внедрить, когда существует несколько кандидатов для зависимости.

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

Проблема выбора между несколькими бинами

Рассмотрим пример: у нас есть несколько реализаций одного интерфейса, и нам нужно выбрать конкретную реализацию для внедрения. Без использования @Qualifier Spring не сможет автоматически решить, какой бин использовать, и выбросит исключение NoUniqueBeanDefinitionException.
@Component
public class EmailService implements NotificationService {
@Override
public void sendNotification(String message) {
System.out.println("Отправка email: " + message);
}
}

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

@Component
public class NotificationClient {

@Autowired
private NotificationService notificationService;

public void process() {
notificationService.sendNotification("Привет!");
}
}
В данном примере NotificationClient не сможет корректно работать, так как Spring не знает, какой бин — EmailService или SmsService — использовать для внедрения.


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

Чтобы указать Spring, какой бин использовать, мы добавляем аннотацию @Qualifier, в которой указываем имя конкретного бина.
@Component
public class EmailService implements NotificationService {
@Override
public void sendNotification(String message) {
System.out.println("Отправка email: " + message);
}
}

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

@Component
public class NotificationClient {

private final NotificationService notificationService;

// Указываем, что нужно использовать EmailService
@Autowired
public NotificationClient(@Qualifier("emailService") NotificationService notificationService) {
this.notificationService = notificationService;
}

public void process() {
notificationService.sendNotification("Привет!");
}
}
Здесь с помощью @Qualifier("emailService") мы указываем Spring, что для зависимости NotificationService нужно использовать именно бин emailService.


#Java #Training #Spring #Qualifier
Использование @Qualifier на уровне поля

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

Пример с использованием на поле
@Component
public class NotificationClient {

@Autowired
@Qualifier("smsService") // Указываем бин smsService
private NotificationService notificationService;

public void process() {
notificationService.sendNotification("Привет!");
}
}


Использование @Qualifier с коллекциями

В некоторых случаях может потребоваться внедрить несколько бинов одного типа. Для этого можно использовать коллекции и
@Qualifier для выбора конкретных бинов.

Пример с коллекцией бинов
@Component
public class NotificationProcessor {

private final List<NotificationService> notificationServices;

@Autowired
public NotificationProcessor(@Qualifier("emailService") List<NotificationService> notificationServices) {
this.notificationServices = notificationServices;
}

public void processAll(String message) {
for (NotificationService service : notificationServices) {
service.sendNotification(message);
}
}
}
В этом примере Spring внедрит все бины, реализующие интерфейс NotificationService, в виде списка.


Использование @Qualifier с кастомными именами бинов

Spring автоматически создаёт имя бина, используя имя класса с маленькой буквы. Однако с помощью аннотации @Component можно указать своё имя бина, а затем использовать это имя в @Qualifier.

Пример с кастомным именем бина
@Component("customEmailService")
public class EmailService implements NotificationService {
@Override
public void sendNotification(String message) {
System.out.println("Отправка email: " + message);
}
}

@Component
public class NotificationClient {

@Autowired
@Qualifier("customEmailService") // Указываем кастомное имя бина
private NotificationService notificationService;

public void process() {
notificationService.sendNotification("Привет!");
}
}


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

Задача по 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
Подробный разбор решения задачи 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
Всем доброго субботнего утра!☀️

Сегодня никаких заданий писать не буду, так как большинство их даже не читает, а я трачу изрядное количество личного времени на это😐😉

Давайте просто отдохнем, а я постараюсь подготовить что-то интересное на завтра💪

И кстати, отсутствие обратной связи от Вас, мои уважаемые подписчики, изрядно демотивирует😔, особенно тогда, когда из нашей, и так немногочисленной группы, народ уходит по 5 человек за раз...🤨

На фоне этого вопрос - чего не хватает нашему каналу, чтобы Вы считали его лучшим и исключительным🧐?

На полном серьезе напишите это в комментариях, а я учту это и изо всех сил постараюсь это сделать.

🫡
This media is not supported in your browser
VIEW IN TELEGRAM
Всем доброе утро!🔆

Сегодня в 16:00 по МСК я приглашаю Вас на лайф-кодинг.

Сегодня я постараюсь рассказать Вам, как работают простейшие нейросети и мы напишем элементарный код который нам это продемонстрирует!)😉

Приходите, будет интересно!✌️
Встреча создана - подключаемся!🤌

https://telemost.yandex.ru/j/98297981728791
Пишем свою нейросеть! Подробные разъяснения и примеры кода. Встреча от 27.10.2024

Запись нашей сегодняшней встречи -
YOUTUBE
RUTUBE

Спасибо тем кто смог прийти, за участие и вопросы!💪

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

Смотрите, комментируйте, задавайте вопросы! Обязательно подписывайтесь на ютуб и рутюб каналы!!!

Ссылка на GitHub - https://github.com/Oleborn/NeuronNet

Всем теплого вечера и хорошего настроения! 🫡✌️