Java for Beginner

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

Anonymous Quiz

19%

21 voters149 views08:48

Java for Beginner

Без комментариев! 😂🤪

https://t.me/Java_for_beginner_dev

#Mems

165 views10:39

Java for Beginner

Контейнер Inversion of Control (IoC)

Контейнер Inversion of Control (IoC) - это ключевая часть Spring Framework, которая управляет созданием, конфигурированием и жизненным циклом объектов. Понимание работы этого контейнера является основополагающим для успешного использования Spring Framework.

Inversion of Control (обратное управление) — это принцип, при котором управление созданием и связыванием зависимостей передается стороннему компоненту, а не остается в руках самого приложения. Идея IoC заключается в том, что вместо того, чтобы объекты сами создавали свои зависимости, этот процесс передается IoC-контейнеру, который управляет этим за вас.

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

Как работает контейнер IoC?

Контейнер IoC в Spring основан на механизме Dependency Injection (DI), который представляет собой процесс передачи зависимостей (объектов) классу вместо их самостоятельного создания.

Контейнер IoC отвечает за:
Создание объектов.
Конфигурирование объектов: связывание их друг с другом.
Управление их жизненным циклом: инициализация и завершение объектов.

IoC-контейнер может использовать два основных метода внедрения зависимостей:
Конструкторное внедрение.
Внедрение через сеттеры (или поля).

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

Принцип работы IoC на примере

Для демонстрации работы IoC рассмотрим пример простого приложения, где один класс зависит от другого. Допустим, у нас есть интерфейс MessageService, который должен отправлять сообщение, и два класса, его реализующих — EmailService и SMSService. Мы создадим контроллер MessageController, который будет использовать MessageService для отправки сообщений.

1. Создание интерфейса MessageService

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

2. Реализация интерфейса MessageService двумя классами

import org.springframework.stereotype.Service;

// Реализация отправки через email
@Service
public class EmailService implements MessageService {

    @Override
    public void sendMessage(String message, String receiver) {
        System.out.println("Email отправлено " + receiver + " с сообщением: " + message);
    }
}

import org.springframework.stereotype.Service;

// Реализация отправки через SMS
@Service
public class SMSService implements MessageService {

    @Override
    public void sendMessage(String message, String receiver) {
        System.out.println("SMS отправлено " + receiver + " с сообщением: " + message);
    }
}

3. Создание контроллера, который использует MessageService

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class MessageController {

    private MessageService messageService;

    // Конструкторное внедрение зависимости
    @Autowired
    public MessageController(MessageService messageService) {
        this.messageService = messageService;
    }

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

#Java #Training #Spring #IoC

138 views14:09

Java for Beginner

4. Конфигурация и запуск Spring-контекста

Контейнер IoC определяет, какой класс использовать в качестве реализации интерфейса MessageService, и передает его в контроллер MessageController. Пример конфигурации 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);

        MessageController controller = context.getBean(MessageController.class);
        controller.processMessage("Привет, как дела?", "user@example.com");
    }
}

5. Конфигурация приложения

Конфигурация Spring может быть задана с помощью XML или Java-аннотаций. В этом примере используем Java-конфигурацию:

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

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

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

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

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

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

#Java #Training #Spring #IoC

128 views14:09

Java for Beginner

Принципы Dependency Injection (DI)

Dependency Injection (DI) — один из основных паттернов проектирования, который активно применяется в Spring Framework. Это концепция, которая обеспечивает инверсию управления (Inversion of Control, IoC), позволяя передавать зависимости объектам извне, а не создавать их внутри самого объекта.

Что такое Dependency Injection?
Dependency Injection (внедрение зависимостей) — это процесс передачи зависимостей объекту, который их использует, извне. Зависимостью считается любой объект, который необходим классу для выполнения своей работы. Принцип DI нарушает традиционное создание зависимостей внутри класса (например, через оператор new) и передает управление их созданием IoC-контейнеру Spring.

Таким образом, класс сам по себе не знает и не управляет созданием своих зависимостей. Это делает код более гибким, тестируемым и облегчает его поддержку. Контейнер Spring отвечает за:
Создание объектов (бинов).
Связывание объектов между собой.
Управление жизненным циклом объектов.
Разрешение зависимостей при инициализации объектов.

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

Принципы Dependency Injection

Основные принципы DI включают:
Инверсия управления (IoC) — изменение направления управления зависимостями. Объекты не управляют своими зависимостями, а получают их извне.
Слабая связанность — классы не зависят от конкретных реализаций своих зависимостей, а используют интерфейсы. Это облегчает замену компонентов и тестирование.
Разделение обязанностей — каждый класс сосредоточен на выполнении своих задач, а создание зависимостей выполняется другим компонентом.
Упрощение конфигурации — зависимости можно легко управлять с помощью XML-конфигураций, аннотаций или Java-кода.

Типы Dependency Injection

В Spring Framework существует два основных способа внедрения зависимостей:
Внедрение через конструктор (Constructor Injection).
Внедрение через сеттер (Setter Injection).

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

Constructor Injection — это тип DI, при котором зависимости передаются классу через его конструктор. Данный подход рекомендуется использовать, если зависимость обязательна и объект не может функционировать без нее. В Spring внедрение через конструктор легко реализуется с помощью аннотации @Autowired или через конфигурацию XML.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

// Интерфейс для сервиса отправки сообщений
interface MessageService {
    void sendMessage(String message);
}

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

// Класс-клиент, зависящий от MessageService
@Component
class MessageProcessor {

    private final MessageService messageService;

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

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

Преимущества внедрения через конструктор:
Обеспечивает неизменяемость объекта, так как все зависимости передаются при создании.
Явно указывает на наличие зависимостей, что улучшает читаемость кода.
Избегает создания объекта с незавершенным состоянием.

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

#Java #Training #Spring #Dependency_Injection

136 views05:39

Java for Beginner

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

Setter Injection — это тип DI, при котором зависимости передаются через методы-сеттеры после создания объекта. Этот подход удобен для опциональных зависимостей, когда объект может функционировать без определенной зависимости.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

// Класс-клиент, зависящий от MessageService
@Component
class NotificationProcessor {

    private MessageService messageService;

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

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

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

Недостатки:
Может привести к созданию объекта в несогласованном состоянии, если сеттеры не вызываются.
Усложняет тестирование, так как зависимости могут меняться в течение жизненного цикла объекта.
Когда использовать какой тип DI?

Constructor Injection используется, когда:
Зависимость обязательна и необходима для корректной работы объекта.
Необходима неизменяемость объекта.
Количество зависимостей невелико и их можно передать через конструктор.

Setter Injection используется, когда:
Зависимость опциональна.
Зависимость должна изменяться после создания объекта.
Количество зависимостей велико, и передача через конструктор делает код нечитаемым.

Практическое использование аннотаций

В Spring внедрение через конструктор и сеттеры можно легко управлять с помощью аннотации @Autowired:
Для конструктора: @Autowired размещается над конструктором.
Для сеттера: @Autowired размещается над методом-сеттером.
Кроме того, можно использовать аннотацию @Required для указания, что определенная зависимость должна быть передана через сеттер, что гарантирует корректную конфигурацию бина.

#Java #Training #Spring #Dependency_Injection

125 views05:39

Java for Beginner

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

Задание на #Dependency_Injection

public class Task181024 {
    public static void main(String[] args) {
        ServiceA serviceA = new ServiceA(new ServiceB());
        serviceA.printMessage();
    }
}

interface Service {
    void printMessage();
}

class ServiceA implements Service {
    private final ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    @Override
    public void printMessage() {
        System.out.println("Message from " + serviceB.getMessage());
    }
}

class ServiceB {
    public String getMessage() {
        return "ServiceB";
    }
}

#Tasks

153 views08:44

Java for Beginner

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

Anonymous Quiz

ServiceA: ServiceB

83%

Message from ServiceB

NullPointerException

No message found

"Hello World"

23 voters144 views08:48

Java for Beginner

Жизненная ситуация😂

https://t.me/Java_for_beginner_dev

#Mems

169 views10:39

Java for Beginner

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

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

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

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

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

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

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

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

@Component
public class SimpleBean {

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

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

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

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

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

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

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

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

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

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {

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

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

#Java #Training #Spring #Spring_Container

123 views14:09

Java for Beginner

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#Java #Training #Spring #Spring_Container

100 views14:09

Java for Beginner

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

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

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

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

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

class MyService {
    private final Dependency dependency;

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

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

class Dependency {
    private final String message;

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

    public String getMessage() {
        return message;
    }
}

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

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

#TasksSpring

126 views14:59

Java for Beginner

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

Anonymous Quiz

38%

false/n Injected Dependency Message

54%

true/n Injected Dependency Message

true/n NullPointerException

false/n NullPointerException

true/n FuckingSpring

13 voters125 views15:04

Java for Beginner

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

Создание контекста: При инициализации ApplicationContext с помощью AnnotationConfigApplicationContext(AppConfig.class) Spring загружает конфигурационный класс AppConfig и создает все объявленные бины.

Создание MyService: Метод myService() в AppConfig создает и возвращает один экземпляр MyService (по умолчанию область действия — singleton). То есть, service1 и service2 указывают на тот же экземпляр MyService, поэтому выражение service1 == service2 выводит true.

Создание Dependency: В методе myService() вызывается метод dependency(), помеченный как @Scope("prototype"), что означает создание нового объекта Dependency каждый раз при его вызове. Поэтому даже если MyService один и тот же, каждый его экземпляр использует свой объект Dependency.

Вывод:

service1 == service2 — true (оба указывают на один и тот же экземпляр MyService).
Метод getDependencyMessage() у service1 выводит строку "Injected Dependency Message".

#Solution_TasksSpring

135 views15:29

Java for Beginner

Всем доброго субботнего утра!☀️

Сегодня в рамках закрепления работы с Spring я планирую дать Вам простое самостоятельное задание. ⚠️

Выполнив его Вы сможете на личном примере закрепить все что мы до этого изучили.🤓

Для тех кому пока тяжеловато, подробную инструкцию по написанию этого задания я выложу в 15:00 по МСК.🫡

Всем отличных выходных))🤝✌️

145 viewsedited 01:22

Java for Beginner

Пробное задание.

Создание и конфигурация приложения с использованием Spring Framework для управления зависимостями и жизненным циклом бинов

Цель:
Выполнить комплексное задание для закрепления теоретических и практических знаний по темам IoC контейнера, Dependency Injection, конфигурации Spring, управлению бинами, их жизненным циклом и внедрению зависимостей.

Описание задачи:
Создайте простой Spring-проект (Java). В этом проекте должно быть реализовано приложение для управления процессом обработки заказов интернет-магазина.

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

Настройте Spring-контейнер для управления объектами с использованием XML-конфигурации. Определите как минимум два бина (например, OrderService и PaymentService) и настройте их взаимодействие через Dependency Injection. Один бин должен быть внедрен через конструктор, другой — через сеттер.

Пример XML конфигурации:

<bean id="orderService" class="com.example.OrderService">
   <constructor-arg ref="paymentService"/>
</bean>
<bean id="paymentService" class="com.example.PaymentService"/>

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

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

@Component
public class OrderService {
    private PaymentService paymentService;

    @Autowired
    public OrderService(@Qualifier("paypalService") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

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

Исследуйте, как Spring управляет созданием и уничтожением объектов (бинов). Настройте бин, который будет в единственном экземпляре (синглтон) и бин, который будет создаваться при каждом запросе (прототип).

<bean id="singletonService" class="com.example.SingletonService" scope="singleton"/>
<bean id="prototypeService" class="com.example.PrototypeService" scope="prototype"/>

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

Реализуйте логику, которая будет выводить сообщения на консоль при инициализации и уничтожении бина. Используйте методы @PostConstruct и @PreDestroy для аннотаций или аналогичные XML-настройки.

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

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

Использование Dependency Injection через конструктор и сеттеры

Продемонстрируйте разницу между внедрением зависимостей через конструктор и сеттеры на примере различных сервисов приложения (OrderService, PaymentService, и т.д.).

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

Опишите и реализуйте использование шаблонов проектирования в Spring, таких как:
Синглтон: для одного из сервисов (например, сервис обработки заказов).
Фабрика: создайте фабричный метод для получения объектов (например, создание различных типов оплат).

Требования к реализации:

Настройте проект на основе Maven или Gradle.
Используйте зависимости для Spring Core (и опционально Spring Context, Spring Beans).
Реализуйте конфигурацию как через XML, так и с помощью аннотаций.
Попробуйте покрыть код базовыми unit-тестами для проверки работоспособности DI и жизненного цикла бинов.
Продемонстрируйте работу приложения с выводом на консоль ключевых этапов жизненного цикла бинов и их взаимодействия.

Результаты можете скидывать в виде скриншотов в комментарии, для совместного разбора и оценки)))
Если возникнут вопросы - жду Вас в комментариях или нашем чате - https://t.me/Java_Beginner_chat

Всем успехов)🫡

#Test_Task

177 viewsedited 01:27

Java for Beginner

Подробное руководство по каждому пункту задания от 19.10.2024

1. Создание Spring-проекта

Чтобы начать работу с Spring, сначала необходимо создать проект. Для этого мы будем использовать Maven или Gradle — системы управления зависимостями, которые помогут нам подключить нужные библиотеки.

Создание проекта с Maven:
Создайте проект с Maven через командную строку или в IDE (например, IntelliJ IDEA).
Если используете IntelliJ, выберите "Create New Project" → "Maven" и создайте пустой проект.
В pom.xml добавьте зависимость Spring Framework:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.28</version>
    </dependency>
</dependencies>

Создание проекта с Gradle:
В IntelliJ выберите "Create New Project" → "Gradle" и создайте проект.
В файле build.gradle добавьте:

dependencies {
    implementation 'org.springframework:spring-context:5.3.28'
}

Комментарий: я лично всегда работаю с Maven и он мне привычнее. Создаю проект также просто через новый проект - выбрать Spring boot - создать проект, и все основные модули для работы Spring уже есть.

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

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

Создание XML конфигурации:
В корневом каталоге проекта создайте папку resources и добавьте туда файл applicationContext.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">

    <bean id="paymentService" class="com.example.PaymentService"/> естественно путь укажите свой
    <bean id="orderService" class="com.example.OrderService">
        <constructor-arg ref="paymentService"/>
    </bean>
</beans>
Здесь мы определили два бина: OrderService и PaymentService. В OrderService внедряется зависимость через конструктор.

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

Создайте класс PaymentService:

package com.example;

public class PaymentService {
    public void processPayment() {
        System.out.println("Payment processed.");
    }
}

Создайте класс OrderService с внедрением зависимости через конструктор:

package com.example;

public class OrderService {
    private PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

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

Загрузка контекста Spring и запуск приложения:
В главном классе приложения создайте код для загрузки Spring контекста:

package com.example;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderService orderService = context.getBean("orderService", OrderService.class);
        orderService.placeOrder();
    }
}
Теперь при запуске приложения Spring контейнер создаст объекты и внедрит зависимости согласно XML конфигурации.

Результат: приложение скомпилируется и при запуске приложения в консоль выведутся сообщения

Order placed.
Payment processed.

#Test_Task_Management

155 views11:59

Java for Beginner

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

Мы можем настроить приложение без XML, используя аннотации. Это позволяет упростить конфигурацию и делать её более читаемой.

Использование аннотации @Component:
В классе PaymentService добавьте аннотацию @Component, чтобы Spring знал, что это бин:

package com.example;

import org.springframework.stereotype.Component;

@Component
public class PaymentService {
    public void processPayment() {
        System.out.println("Payment processed.");
    }
}

Внедрение зависимости через @Autowired:
В классе OrderService добавьте конструктор с аннотацией @Autowired, чтобы Spring автоматически внедрил зависимость:

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class OrderService {
    private PaymentService paymentService;

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

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

Создание конфигурационного класса:
Вместо XML можно создать конфигурационный класс:

package com.example;

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

@Configuration
@ComponentScan("com.example") - не забудьте верно указать директорию которую будет сканировать Spring для поиска бинов
public class AppConfig {
}

В классе Main используйте аннотированную конфигурацию:

package com.example;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        OrderService orderService = context.getBean(OrderService.class);
        orderService.placeOrder();
    }
}

Результат: приложение скомпилируется и при запуске приложения в консоль выведутся сообщения

Order placed.
Payment processed.

#Test_Task_Management

110 views11:59

Java for Beginner

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

Spring контейнер поддерживает различные scopes (области видимости) для бинов:
Синглтон — бин создается один раз на все приложение.
Прототип — бин создается каждый раз, когда он запрашивается.

Пример настройки синглтона и прототипа:
В классе конфигурации добавьте 2 класса бинов с разными скоупами (если кто забыл или не знал скоуп Singleton идет по умолчанию):

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

@Component
public class SingletonService {
    public void doSomething() {
        System.out.println("Singleton instance: " + this);
    }
}

и с скоупом прототип:

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

@Component
@Scope("prototype")
public class PrototypeService {
    public void doSomething() {
        System.out.println("Prototype instance: " + this);
    }
}

Вызовите оба бина в Main, чтобы увидеть, как работает область видимости:

        // Получение синглтон-бинов (должны быть одинаковыми)
        SingletonService singleton1 = context.getBean(SingletonService.class);
        SingletonService singleton2 = context.getBean(SingletonService.class);

        // Получение прототип-бинов (должны быть разными)
        PrototypeService prototype1 = context.getBean(PrototypeService.class);
        PrototypeService prototype2 = context.getBean(PrototypeService.class);

        // Проверка синглтон-бинов
        System.out.println("Checking Singleton beans:");
        if (singleton1 == singleton2) {
            System.out.println("Singleton1 and Singleton2 are the same instance.");
        } else {
            System.out.println("Singleton1 and Singleton2 are different instances.");
        }

        // Проверка прототип-бинов
        System.out.println("\nChecking Prototype beans:");
        if (prototype1 == prototype2) {
            System.out.println("Prototype1 and Prototype2 are the same instance.");
        } else {
            System.out.println("Prototype1 and Prototype2 are different instances.");
        }

        // Вывод информации о бин-объектах
        System.out.println("\nSingleton bean instances:");
        singleton1.doSomething();
        singleton2.doSomething();

        System.out.println("\nPrototype bean instances:");
        prototype1.doSomething();
        prototype2.doSomething();

#Test_Task_Management

118 views11:59

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

About

Blog

Apps

Platform