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