Spring Framework - это платформа для разработки Java-приложений, которая предоставляет обширный набор инструментов и модулей для упрощения создания приложений. Вот некоторые из основных модулей Spring:

Spring Core Container - этот модуль предоставляет основные функции фреймворка, такие как управление бинами, внедрение зависимостей и управление жизненным циклом бинов.
Spring AOP (Aspect-Oriented Programming) - этот модуль позволяет создавать аспектно-ориентированные аспекты, такие как логирование, транзакции и безопасность.
Spring JDBC (Java Database Connectivity) - модуль, предоставляющий удобные средства для работы с базами данных и упрощающий кодирование доступа к данным.
Spring MVC (Model-View-Controller) - этот модуль предоставляет возможность создания веб-приложений с использованием шаблона проектирования MVC.
Spring Security - модуль для обеспечения безопасности приложений, включающий функции аутентификации, авторизации и защиты от атак.

2.`Удобство и простота использования`

3.`Микросервисная архитектура`

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

Преимущества микросервисной архитектуры Микросервисная архитектура имеет несколько преимуществ, включая:

Гибкость и масштабируемость: Микросервисы могут быть разработаны и развернуты независимо друг от друга, что позволяет гибко масштабировать и изменять отдельные компоненты приложения.
Легкость в разработке и поддержке: Разделение приложения на микросервисы упрощает разработку и поддержку, поскольку каждый сервис может быть разработан и поддерживаться отдельной командой.
Улучшенная отказоустойчивость: Если один микросервис выходит из строя, остальные микросервисы продолжают работать нормально, что повышает отказоустойчивость системы.
Технологическая свобода: Каждый микросервис может использовать разные технологии и языки программирования, что позволяет выбрать наиболее подходящие инструменты для каждой конкретной задачи.

Примеры использования микросервисной архитектуры Микросервисная архитектура широко применяется в различных областях, включая:

Веб-приложения: Микросервисная архитектура позволяет разделить функциональность веб-приложения на отдельные сервисы, такие как аутентификация, обработка платежей и управление контентом.
Интернет вещей (IoT): Микросервисная архитектура может быть использована для разработки и управления сложными системами IoT, где различные устройства и сервисы взаимодействуют между собой.
Облачные вычисления: Облачные провайдеры, такие как Amazon Web Services (AWS), используют микросервисную архитектуру для предоставления различных сервисов, таких как хранение данных, обработка изображений и машинное обучение.
API-сервисы: Микросервисная архитектура может быть использована для создания API-сервисов, которые предоставляют доступ к функциональности приложения через стандартные интерфейсы, такие как REST API.

Заключение Микросервисная архитектура - это подход к построению приложений, который разделяет их на независимо развертываемые сервисы. Она обладает преимуществами гибкости, масштабируемости, легкости в разработке и поддержке, а также улучшенной отказоустойчивости. Микросервисная архитектура широко применяется в различных областях, включая веб-приложения, IoT, облачные вычисления и API-сервисы.

4.`Support & Community`

5.`Что нужно знать для изучения курса Spring`

`lesson 2. Установка программного обеспечения`

6.`Установка Java 17`

Для установки Java 17 на Mac и Windows, вам потребуется выполнить следующие шаги:

Для Windows:

Скачайте установщик JDK с сайта AdoptOpenJDK. Выберите соответствующую версию в зависимости от разрядности вашей операционной системы: Windows 32bit или Windows 64bit. Установите JDK, следуя инструкциям установщика.

Для Mac:

Перейдите на сайт adoptium.net. Скачайте установщик для Mac. Установите JDK, следуя инструкциям установщика. Примечание: После установки JDK, убедитесь, что переменная окружения JAVA_HOME указывает на установленный JDK.

7.`Установка IntelliJ IDEA Ultimate Edition`

8.`Установка PostgreSQL`

Для установки PostgreSQL на Windows, вы можете использовать следующие шаги:

Эти шаги должны помочь вам установить PostgreSQL на Windows.

Скачайте установочный файл PostgreSQL с официального сайта по ссылке: https://www.postgresql.org/download/windows/ . Запустите установочный файл и следуйте инструкциям мастера установки, нажимая "Next" для перехода к следующему шагу.

Выберите необходимые компоненты для установки, такие как клиентские утилиты, сервер и дополнительные инструменты.

Укажите порт для сервера PostgreSQL (по умолчанию 5432) и настройте другие параметры, если необходимо.

Создайте пароль для пользователя "postgres" и завершите установку, нажав "Next" и затем "Finish".

После установки, вы можете запустить PostgreSQL, используя командную строку или другие утилиты.

Установка PostgreSQL на Mac Для установки PostgreSQL на Mac, вы можете воспользоваться следующими шагами:

Используйте Homebrew для установки PostgreSQL на Mac OS. Вы можете выполнить следующие команды в терминале:

brew install postgresql

После установки, вы можете запустить PostgreSQL, используя командную строку или другие утилиты.

Для управления PostgreSQL на Mac, вы можете использовать различные инструменты, такие как PgAdmin или другие графические интерфейсы.

Эти шаги помогут вам установить PostgreSQL на Mac OS.

9.`Установка Docker`

Для установки Docker на Windows и Mac, вам потребуется скачать и установить Docker Desktop. Вот краткое руководство по установке:

Windows:

Скачайте и установите Docker Desktop для Windows с официального сайта Docker. Убедитесь, что ваша операционная система соответствует системным требованиям Docker Desktop. После установки запустите Docker Desktop и следуйте инструкциям по настройке.

Mac:

Скачайте и установите Docker Desktop для Mac с официального сайта Docker. Убедитесь, что ваша операционная система соответствует системным требованиям Docker Desktop. После установки запустите Docker Desktop и следуйте инструкциям по настройке.

10.`Создание нового проекта`

Для создания нового проекта Spring вы можете использовать Spring Initializr, который позволяет быстро и легко настроить и сгенерировать проект Spring. Вот как вы можете это сделать:

Используйте Spring Initializr: Вы можете использовать Spring Initializr, доступный по адресу https://start.spring.io/, чтобы создать новый проект Spring. Выберите необходимые зависимости и настройки проекта, а затем сгенерируйте проект.
Выберите необходимые зависимости: При создании проекта Spring вы можете выбрать необходимые зависимости, такие как Spring Boot, JDK, Maven и другие, в зависимости от ваших потребностей.
Структура проекта: После создания проекта вы увидите стандартную структуру проекта, которая включает каталоги src/main/java для исходного кода и pom.xml для управления зависимостями с помощью Maven.
Дополнительные настройки: В зависимости от ваших потребностей, вы также можете добавить дополнительные настройки, такие как настройку базы данных, настройку безопасности, создание контроллеров и служб и другие.

`lesson 3. Inversion of Control. Dependency Injection`

11.`Object Dependencies`

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

Источник указывает, что DI является частью концепции Inversion of Control (IoC), которая изменяет способ, которым объекты получают свои зависимости. Вместо того, чтобы объект самостоятельно создавать свои зависимости, они внедряются в объект извне.

Источник уточняет, что Dependency Injection (DI) может использоваться для управления зависимостями в различных технологиях, таких как Spring Framework в Java.

Таким образом, Object Dependencies (зависимости объектов) в контексте программирования относятся к способу управления зависимостями между объектами в приложении с использованием концепции Dependency Injection (DI).

12.`Object Dependencies в коде`

13.`Inversion of Control & Dependency Injection`

14.`Inversion of Control & Dependency Injection в коде`

15.`3 способа внедрения зависимостей в объекте`

`lesson 4. IoC Container`

16.`Spring IoC Container`

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

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

ApplicationContext context = new ClassPathXmlApplicationContext("services.xml"); Этот код инициализирует контейнер приложения Spring и загружает конфигурацию из файла "services.xml".

Spring IoC Container также известен как Spring Container и предоставляет механизм для управления объектами приложения и их зависимостями.

Итак, Spring IoC Container играет важную роль в управлении объектами и их зависимостями в приложениях, обеспечивая гибкость и удобство в разработке.

17.`Bean`

Bean - это ключевое понятие в Spring Framework. Это объекты, которые являются основой вашего приложения и управляются контейнером управления инверсией управления (IoC) Spring. Bean - это объект, который создается, собирается и управляется контейнером управления инверсией управления Spring IoC. Он может быть описан с помощью аннотаций, таких как @Bean, @Component и других, или с использованием XML-конфигурации. Bean также может иметь различные характеристики, такие как класс, имя, область видимости и другие.

Дополнительно, bean в Spring Framework также связан с понятием Dependency Injection (DI). Он играет важную роль в создании гибкой и модульной архитектуры приложения, позволяя внедрять зависимости между компонентами приложения.

Итак, bean в Spring Framework представляет собой объект, управляемый контейнером управления инверсией управления Spring IoC, который обеспечивает гибкую и модульную архитектуру приложения.

18.`Bean Definition`

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

Пример использования bean в Spring можно увидеть в следующем коде:

@Configuration
public class LessonsConfiguration {
    @Bean
    public BeanWithDependency beanWithDependency() {
        return new BeanWithDependency(greetingService());
    }

    @Bean
    public GreetingService greetingService() {
        return new GreetingServiceImpl();
    }
}

19.`POJO`

POJO в контексте Spring означает "Plain Old Java Object" (Простой Старый Java-Объект). Это обычный Java-объект, который не зависит от каких-либо специфических библиотек или фреймворков. В Spring фреймворке, POJO используются для создания компонентов, которые могут быть управляемыми контейнером Spring.

Spring - это фреймворк для разработки приложений на языке Java. Он предоставляет множество готовых решений для упрощения разработки, таких как управление зависимостями, внедрение зависимостей, управление транзакциями и многое другое.

Пример простого POJO класса в Spring может выглядеть следующим образом:

public class User {
    private String name;
    private int age;

    // геттеры и сеттеры
}

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

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

20.`Основные интерфейсы IoC Container`

IoC Container (Inversion of Control Container) предоставляет различные интерфейсы для управления зависимостями и контроля жизненного цикла объектов.

Из поисковых результатов видно, что основные интерфейсы IoC Container включают:

ApplicationContext в Spring Framework, который предоставляет механизм для управления конфигурацией приложения, создания бинов и управления их жизненным циклом.
XML-конфигурации в Spring Framework, которая позволяет определять бины и их зависимости в XML-файлах.
BeanFactory в Spring Framework, предоставляющая расширенную модель конфигурации и управления бинами.
Container interface в PHP, такой как в Laravel, который предоставляет методы для регистрации и разрешения зависимостей.
Inversion of Control (IoC), который предоставляет механизм для управления созданием и жизненным циклом объектов.

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

21.`3 способа создания Bean Definitions`

В Spring Framework существует несколько способов создания определений бинов. Некоторые из них включают:

Аннотации (@Component, @Service, @Repository, @Controller): В Spring Framework можно использовать аннотации, такие как @Component, @Service, @Repository, @Controller для создания определений бинов. Например: import org.springframework.stereotype.Component;

@Component
public class SimpleBean {
    public String hello() {
        return "Hello world!";
    }
}

XML-конфигурация: Другим способом создания определений бинов в Spring Framework является использование XML-конфигурации. Это позволяет определять бины в XML-файлах. Например:

<bean id="simpleBean" class="com.example.SimpleBean">
    <property name="message" value="Hello world!" />
</bean>

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

@Configuration
public class AppConfig {
    @Bean
    public SimpleBean simpleBean() {
        return new SimpleBean();
    }
}

Эти способы предоставляют различные подходы к созданию определений бинов в Spring Framework, и выбор конкретного способа может зависеть от конкретных потребностей проекта.

2. XML-based Configuration

lesson 5. XML-based Configuration

22.`BeanFactory и ApplicationContext интерфейсы`

BeanFactory и ApplicationContext - это интерфейсы в Spring Framework, используемые для управления, конфигурирования и манипулирования бинами.

BeanFactory предоставляет основные функции для управления и манипулирования бинами в программном виде, в то время как ApplicationContext предоставляет дополнительные функции, такие как доступ к ресурсам, распространение событий на бины, загрузку нескольких (иерархических) контекстов и другие возможности в более ориентированном на фреймворк стиле.

ApplicationContext расширяет функциональность BeanFactory и предоставляет дополнительные возможности, такие как доступ к ресурсам, распространение событий на бины, загрузку нескольких (иерархических) контекстов и другие возможности в более ориентированном на фреймворк стиле.

Важно отметить, что ApplicationContext предоставляет дополнительные функции, такие как MessageSource, доступ к ресурсам, распространение событий на бины, загрузку нескольких (иерархических) контекстов и другие возможности в более ориентированном на фреймворк стиле.

Различия между BeanFactory и ApplicationContext:

Интерфейсы IOC (Inversion of Control):

BeanFactory является основным интерфейсом для доступа к контейнеру Spring, обеспечивающим управление бинами и их зависимостями через механизм IOC. ApplicationContext расширяет функциональность BeanFactory и предоставляет дополнительные возможности, такие как обработка событий, межбиновые ссылки, доступ к ресурсам и многое другое.

Производительность и гибкость:

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

Поддержка аннотаций:

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

Обработка событий:

ApplicationContext предоставляет возможность обработки событий, что позволяет реагировать на различные события в контейнере Spring.

Межбиновые ссылки и доступ к ресурсам:

ApplicationContext позволяет легко устанавливать межбиновые ссылки и получать доступ к различным ресурсам, таким как файлы, URL-адреса и т. д..

В заключение, хотя BeanFactory и ApplicationContext оба предоставляют возможности управления бинами в Spring Framework, ApplicationContext предоставляет более широкий спектр функциональности и обычно является предпочтительным выбором для большинства приложений.

23.`ClassPathXmlApplicationContext`

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

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

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); Person person = (Person) context.getBean("person"); System.out.println(person.getId() + ":" + person.getName()); ClassPathXmlApplicationContext также позволяет использовать несколько XML-файлов конфигурации для инициализации контейнера Spring. В этом случае бины, определенные в последних загруженных файлах, переопределят бины, определенные в ранее загруженных файлах.

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

ClassPathXmlApplicationContext(String configLocation)
ClassPathXmlApplicationContext(String... configLocations)
ClassPathXmlApplicationContext(String[] configLocations, boolean refresh)

Этот класс также полезен для тестовых сред и демонстрационных целей.

Префикс classpath:* При конструировании контекста приложения, иногда можно использовать префикс classpath*:.

Этот класс также полезен для тестовых сред и демонстрационных целей.

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

24.`XML config`

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

    <bean id="exampleBean" class="com.example.ExampleBean">
        <property name="property1" value="someValue"/>
        <property name="property2" ref="anotherBean"/>
    </bean>

    <bean id="anotherBean" class="com.example.AnotherBean">
        <!-- настройки для другого бина -->
    </bean>

</beans>

Здесь - корневой элемент, в котором определяются все бины приложения. используется для определения бина, его id, класса и свойств. Внутри можно указать значение свойства или ссылку на другой бин.

Основные элементы XML-конфигурации Spring включают в себя:

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

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

25.`Идентификаторы (id) бинов как ключи в IoC Container`

В контейнере управления инверсией управления (IoC) идентификаторы (id) бинов используются в качестве ключей для доступа к объектам, зарегистрированным в контейнере. Вот некоторые ключевые моменты:

Spring IoC Container и типы бинов:

В Spring IoC Container существуют различные типы бинов, такие как singleton, prototype, request и session.
Бины типа singleton создаются один раз и используются повсюду в приложении, в то время как бины типа prototype создаются каждый раз при запросе.
Бины типа request и session связаны с HTTP-запросами и сеансами соответственно.

Регистрация бинов в IoC Container:

Бины регистрируются в контейнере с помощью аннотаций, таких как @Bean и @Component.
Аннотация @Bean используется для указания методов, которые возвращают объекты, которые должны быть зарегистрированы в контейнере.
Аннотация @Component используется для автоматической регистрации классов в контейнере.

Использование идентификаторов (id) бинов:

Идентификаторы (id) бинов используются в качестве ключей для доступа к зарегистрированным объектам в контейнере.
Эти идентификаторы могут быть использованы для получения бинов из контейнера с помощью метода getBean().
Инверсия управления (IoC) и внедрение зависимостей (DI):

IoC и DI являются ключевыми концепциями в управлении зависимостями в приложениях. В IoC контейнере объекты не создаются вручную, а управление их жизненным циклом осуществляется контейнером. DI позволяет внедрять зависимости в объекты, что упрощает управление зависимостями и повышает гибкость приложения. Таким образом, идентификаторы (id) бинов играют важную роль в IoC Container, обеспечивая уникальный доступ к зарегистрированным объектам и управляя их жизненным циклом.

26.`Алиасы бинов (alias)`

В Spring Framework алиасы бинов используются для предоставления альтернативных имен для бинов. Например, если у вас есть бин с именем "myBean", вы можете создать алиас "myAlias" для этого бина. Это может быть полезно для улучшения читаемости кода или обеспечения совместимости с другими системами.

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

В XML-конфигурации Spring:

<bean id="myBean" class="com.example.MyClass" />
<alias name="myAlias" alias="myBean" />

В этом примере "myAlias" является алиасом для бина "myBean".

В Java-конфигурации Spring:

@Component("myBean")
public class MyClass {
    // Код класса
}

В этом случае "myBean" может быть использован как основное имя бина, а затем созданы алиасы для него.

Эти примеры демонстрируют, как можно использовать алиасы для бинов в Spring Framework

Start of Selection

`lesson 6. Внедрение через конструктор (Constructor Injection)`

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

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

Рассмотрим пример, в котором у нас есть класс DatabaseService, который зависит от DatabaseConfig. Мы будем использовать внедрение через конструктор для передачи конфигурации базы данных в сервис.

public class DatabaseService {
    private DatabaseConfig config;

    public DatabaseService(DatabaseConfig config) {
        this.config = config;
    }
}

В этом примере класс DatabaseService имеет конструктор, который принимает параметр типа DatabaseConfig. Spring будет автоматически внедрять экземпляр DatabaseConfig в сервис при создании бина.

27.`Внедрение примитивных типов данных`

В Spring Framework внедрение примитивных типов данных может осуществляться с помощью различных механизмов, таких как аннотации @Value и @Autowired. Давайте рассмотрим примеры внедрения примитивных типов данных в Spring.

Внедрение примитивных типов данных с помощью аннотации @Value: Пример внедрения значения примитивного типа данных с использованием аннотации @Value:

import org.springframework.beans.factory.annotation.Value;

public class MyBean {
    @Value("10")
    private int myNumber;
    // Другие поля и методы класса
}

Этот пример демонстрирует внедрение значения примитивного типа данных (в данном случае, целочисленного) с использованием аннотации @Value.

Внедрение примитивных типов данных с помощью @Autowired: Внедрение примитивных типов данных с использованием @Autowired может осуществляться через конструктор, сеттеры или поля. Например:

Внедрение через конструктор:

public class MyBean {
    private int myNumber;

    @Autowired
    public MyBean(@Value("10") int myNumber) {
        this.myNumber = myNumber;
    }
    // Другие поля и методы класса
}

Этот пример демонстрирует внедрение значения примитивного типа данных через конструктор с использованием аннотации @Autowired и @Value.

Внедрение через сеттеры или поля:

public class MyBean {
    @Value("10")
    private int myNumber;
    // Другие поля и методы класса
}

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

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

28.`Внедрение коллекций list/set`

Spring Framework предоставляет возможность использовать внедрение коллекций (list/set) с помощью конструктора. Это позволяет передавать коллекции объектов в качестве зависимостей. Вот примеры:

Пример внедрения списка (List) с использованием конструктора:

public class CollectionExample {
    private List<String> myList;

    public CollectionExample(List<String> myList) {
        this.myList = myList;
    }
}

Пример внедрения множества (Set) с использованием конструктора:

public class CollectionExample {
    private Set<Integer> mySet;

    public CollectionExample(Set<Integer> mySet) {
        this.mySet = mySet;
    }
}

В обоих примерах Spring будет автоматически внедрять соответствующие коллекции при создании экземпляра класса CollectionExample.

29.`Внедрение ассоциативного массива map`

Spring предоставляет возможность использовать ассоциативные массивы, такие как Map, для хранения пар ключ-значение. Вот пример внедрения ассоциативного массива Map в Spring:

import java.util.Map;

public class MyBean {
    private Map<String, String> myMap;

    // Геттер и сеттер для myMap
    public Map<String, String> getMyMap() {
        return myMap;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }
}

В этом примере класс MyBean содержит поле myMap, которое представляет ассоциативный массив Map с ключами и значениями типа String. Этот Map может быть внедрен в другие компоненты Spring, такие как сервисы или контроллеры, для удобного доступа к данным.

Использование Map в Spring позволяет эффективно управлять парами ключ-значение и обеспечивает гибкость при работе с данными в приложении.

30.`Поле genericArgumentValues в BeanDefinition`

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

Пример использования genericArgumentValues может выглядеть следующим образом:

public class MyBean {
    private List<String> myList;

    public MyBean(List<String> myList) {
        this.myList = myList;
    }
}

В этом примере класс MyBean имеет конструктор, который принимает параметр типа List<String>. Spring будет использовать genericArgumentValues для хранения этого параметра.

31.`Поле indexedArgumentValues в BeanDefinition`

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

Пример использования indexedArgumentValues может выглядеть следующим образом:

public class MyBean {
    private String[] myArray;

    public MyBean(String[] myArray) {
        this.myArray = myArray;
    }
}

32.`Указание атрибута type в параметрах конструктора`

В Spring Framework, когда вы создаете бины, иногда необходимо указать тип параметра конструктора. Это особенно важно, когда у вас есть несколько бинов одного типа, и Spring должен знать, какой именно бин использовать.

Например, предположим, у вас есть два бина, которые оба являются списками строк:

public class MyBean {
    private List<String> myList;

    public MyBean(List<String> myList) {
        this.myList = myList;
    }
}

В этом примере Spring будет использовать тип List<String> для определения, какой именно бин использовать.

33.`Указание атрибута name в параметрах конструктора`

Например, предположим, у вас есть два бина, которые оба являются списками строк:

public class MyBean {
    private List<String> myList;

    public MyBean(List<String> myList) {
        this.myList = myList;
    }
}

В этом примере Spring будет использовать тип List<String> для определения, какой именно бин использовать.

`lesson 7. Factory Method Injection`

Start of Selection

34.`Внедрение других бинов через ref*`

В Spring Framework внедрение других бинов через атрибут ref позволяет ссылаться на уже существующие бины в контексте приложения. Это особенно полезно, когда необходимо использовать один бин в другом, обеспечивая тем самым повторное использование и управление зависимостями.

Пример использования ref в XML-конфигурации может выглядеть следующим образом:

<bean id="myBean" class="com.example.MyBean">
    <property name="otherBean" ref="anotherBean"/>
</bean>

В этом примере myBean использует anotherBean в качестве зависимости.

35.`Создание нового бина CompanyRepository`

Для создания нового бина CompanyRepository в Spring Framework, необходимо определить класс репозитория, который будет отвечать за доступ к данным, связанным с сущностью Company. Обычно это делается с использованием интерфейса, который расширяет JpaRepository или CrudRepository, если вы используете Spring Data JPA.

Пример реализации может выглядеть следующим образом:

public interface CompanyRepository extends JpaRepository<Company, Long> {
    // Методы для доступа к данным
}

В этом примере CompanyRepository расширяет JpaRepository, что позволяет использовать стандартные методы для доступа к данным, такие как save, findById, findAll и т.д.

36.`Внедрение зависимостей через factory method`

Внедрение зависимостей через фабричный метод (factory method) в Spring Framework позволяет создавать бины с использованием методов, которые возвращают экземпляры этих бинов. Это особенно полезно, когда необходимо выполнить некоторую логику перед созданием объекта или когда создание объекта требует сложных параметров.

Фабричный метод может быть определен в классе, который будет выступать в роли фабрики. Например, предположим, что у нас есть класс Car, и мы хотим создать его экземпляр с помощью фабричного метода.

Пример реализации может выглядеть следующим образом:

public class CarFactory {
    public static Car createCar() {
        // Логика для создания объекта Car
        return new Car();
    }
}

В этом примере класс CarFactory содержит статический метод createCar, который возвращает новый экземпляр класса Car.

37.`Атрибут factory-bean (паттерн ServiceLocator)`

Атрибут factory-bean в Spring Framework используется для указания бина, который будет выступать в качестве фабрики для создания других бинов. Это позволяет использовать паттерн Service Locator, который помогает управлять зависимостями и упрощает создание объектов.

Когда вы используете factory-bean, вы можете определить метод в указанном бине, который будет возвращать экземпляр другого бина. Это особенно полезно, когда создание бина требует сложной логики или параметров.

Пример использования factory-bean в XML-конфигурации может выглядеть следующим образом:

<bean id="myBean" factory-bean="myFactoryBean" factory-method="createCar"/>

В этом примере myBean будет создан с помощью метода createCar из бина myFactoryBean.

`lesson 8. Внедрение свойств (Property Injection)`

Внедрение свойств (Property Injection) — это один из способов внедрения зависимостей в Spring Framework, который позволяет устанавливать значения свойств бина через методы set*. Этот подход особенно полезен, когда необходимо настроить бин после его создания, а также когда значения свойств могут изменяться в процессе работы приложения.

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

Рассмотрим пример, в котором мы создаем класс DatabaseConfig, который будет содержать настройки для подключения к базе данных. Мы будем использовать методы set* для внедрения значений свойств.

public class DatabaseConfig {
    private String url;
    private String username;
    private String password;
}

38.`Использование set* методов в ConnectionPool`

Использование методов set* в классе ConnectionPool является распространенной практикой для внедрения зависимостей и настройки параметров пула соединений. Пул соединений — это механизм, который управляет набором соединений с базой данных, позволяя многим клиентам использовать одно и то же соединение, что значительно повышает производительность приложения.

Пример реализации класса ConnectionPool с использованием методов set* может выглядеть следующим образом:

public class ConnectionPool {
    private String url;
    private String username;
    private String password;

    public void setUrl(String url) {
        this.url = url;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

В этом примере класс ConnectionPool имеет методы setUrl, setUsername и setPassword, которые используются для настройки параметров пула соединений.

39.`Поле propertyValues в BeanDefinition`

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

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

<bean id="dataSource" class="com.example.DataSource">
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="user"/>
    <property name="password" value="password"/>
</bean>

В этом примере dataSource будет создан с настроенными значениями свойств url, username и password.

40.`Упрощенный жизненный цикл бинов - Bean Lifecycle`

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

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

Пример:
```
@Component
public class MyBean {
    public MyBean() {
        System.out.println("Бин MyBean создан");
    }
}
```
Настройка бина: После создания бина Spring настраивает его свойства, используя значения, указанные в конфигурации. Это может включать внедрение зависимостей через конструкторы, сеттеры или аннотации.

Пример:
```
@Component
public class MyService {
    private final MyRepository repository;

    @Autowired
    public MyService(MyRepository repository) {
        this.repository = repository;
    }
}
```
Инициализация бина: После настройки бина Spring может вызывать методы инициализации, если они определены. Это позволяет выполнять дополнительные действия, такие как открытие соединений или настройка ресурсов.

Пример:
```
@Component
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("Бин MyBean инициализирован");
    }
}
```
Использование бина: После инициализации бин готов к использованию. Он может быть запрошен другими компонентами или сервисами в приложении.
Уничтожение бина: Когда приложение завершает свою работу или бин больше не нужен, Spring вызывает методы уничтожения, чтобы освободить ресурсы. Это особенно важно для бинов, которые используют внешние ресурсы, такие как соединения с базой данных.

Пример:
```
@Component
public class MyBean {
    @PreDestroy
    public void cleanup() {
        System.out.println("Бин MyBean уничтожен");
    }
}
```

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

41.`Плюсы и минусы Constructor и Property Injections`

В Spring Framework существует два основных способа внедрения зависимостей: через конструктор (Constructor Injection) и через свойства (Property Injection). У каждого из этих подходов есть свои плюсы и минусы, которые стоит рассмотреть.

Плюсы Constructor Injection:

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

Пример:
```
@Component
public class MyService {
    private final MyRepository repository;

    @Autowired
    public MyService(MyRepository repository) {
        this.repository = repository;
    }
}
```
Явность зависимостей: Все зависимости класса явно указаны в его конструкторе, что упрощает понимание того, какие зависимости необходимы для работы класса.
Поддержка обязательных зависимостей: Если зависимость является обязательной, то ее можно сделать обязательным параметром конструктора, что предотвращает создание объекта без необходимых зависимостей.

Минусы Constructor Injection:

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

Пример:

@Component
public class ComplexService {
    private final DependencyA a;
    private final DependencyB b;
    private final DependencyC c;

    @Autowired
    public ComplexService(DependencyA a, DependencyB b, DependencyC c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

Плюсы Property Injection:

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

Пример:
```
@Component
public class MyService {
    private MyRepository repository;

    @Autowired
    public void setRepository(MyRepository repository) {
        this.repository = repository;
    }
}
```
Упрощение конструктора: Если у класса много зависимостей, можно использовать сеттеры для их внедрения, что делает конструктор более простым и понятным.

Минусы Property Injection:

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

Таким образом, выбор между Constructor и Property Injection зависит от конкретных требований вашего приложения и предпочтений команды. Важно учитывать как плюсы, так и минусы каждого подхода при проектировании архитектуры приложения.

Start of Selection

42.`Циклические зависимости через Property Injection`

Циклические зависимости возникают, когда два или более бина зависят друг от друга. Это может привести к проблемам при создании бинов, так как Spring не сможет корректно разрешить зависимости. Однако, с помощью внедрения через свойства (Property Injection) можно обойти эту проблему.

Рассмотрим пример, где у нас есть два бина: BeanA и BeanB. BeanA зависит от BeanB, а BeanB зависит от BeanA.

public class BeanA {
    private BeanB beanB;
}

`lesson 9. Области видимости бинов (Bean Scopes)`

В Spring Framework существует несколько областей видимости (scope) для бинов, которые определяют, как и когда создаются экземпляры бинов. Понимание областей видимости бинов является важным аспектом проектирования приложений на Spring, так как это влияет на управление состоянием и жизненным циклом объектов. Основные области видимости включают:

Singleton: Это область видимости по умолчанию. В этом случае Spring создает только один экземпляр бина для всего приложения. Этот экземпляр будет использоваться при каждом запросе к этому бину. Например:
```
@Component
public class MySingletonBean {
    public MySingletonBean() {
        System.out.println("Создан экземпляр MySingletonBean");
    }
}
```
При каждом запросе к MySingletonBean будет возвращаться один и тот же экземпляр. Это полезно для бинов, которые должны сохранять состояние или кэшировать данные.
Prototype: При этой области видимости Spring создает новый экземпляр бина каждый раз, когда он запрашивается. Это полезно, когда необходимо иметь уникальный экземпляр бина для каждого запроса. Например:
```
@Component
@Scope("prototype")
public class MyPrototypeBean {
    public MyPrototypeBean() {
        System.out.println("Создан экземпляр MyPrototypeBean");
    }
}
```
Каждый раз, когда вы запрашиваете MyPrototypeBean, будет создаваться новый экземпляр. Это может быть полезно для бинов, которые содержат временные данные или состояние, специфичное для конкретного запроса.
Request: Эта область видимости используется в веб-приложениях. Бин с областью видимости request создается для каждого HTTP-запроса. Например:
```
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST)
public class MyRequestBean {
    public MyRequestBean() {
        System.out.println("Создан экземпляр MyRequestBean для HTTP-запроса");
    }
}
```
Каждый HTTP-запрос будет получать новый экземпляр MyRequestBean. Это позволяет сохранять состояние, специфичное для каждого запроса, и освобождать ресурсы после завершения обработки запроса.
Session: Бин с областью видимости session создается для каждой HTTP-сессии. Это означает, что экземпляр будет доступен для всех запросов в рамках одной сессии. Например:
```
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION)
public class MySessionBean {
    public MySessionBean() {
        System.out.println("Создан экземпляр MySessionBean для HTTP-сессии");
    }
}
```
Экземпляр MySessionBean будет доступен для всех запросов в рамках одной сессии, что позволяет сохранять состояние пользователя между запросами.

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

43.`Общие области видимости бинов`

В Spring Framework существует несколько областей видимости (scope) для бинов, которые определяют, как и когда создаются экземпляры бинов. Основные области видимости включают:

Singleton: Это область видимости по умолчанию. В этом случае Spring создает только один экземпляр бина для всего приложения. Этот экземпляр будет использоваться при каждом запросе к этому бину. Например:
```
@Component
public class MySingletonBean {
    public MySingletonBean() {
        System.out.println("Создан экземпляр MySingletonBean");
    }
}
```
При каждом запросе к MySingletonBean будет возвращаться один и тот же экземпляр.
Prototype: При этой области видимости Spring создает новый экземпляр бина каждый раз, когда он запрашивается. Это полезно, когда необходимо иметь уникальный экземпляр бина для каждого запроса. Например:
```
@Component
@Scope("prototype")
public class MyPrototypeBean {
    public MyPrototypeBean() {
        System.out.println("Создан экземпляр MyPrototypeBean");
    }
}
```
Каждый раз, когда вы запрашиваете MyPrototypeBean, будет создаваться новый экземпляр.
Request: Эта область видимости используется в веб-приложениях. Бин с областью видимости request создается для каждого HTTP-запроса. Например:
```
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST)
public class MyRequestBean {
    public MyRequestBean() {
        System.out.println("Создан экземпляр MyRequestBean для HTTP-запроса");
    }
}
```
Каждый HTTP-запрос будет получать новый экземпляр MyRequestBean.
Session: Бин с областью видимости session создается для каждой HTTP-сессии. Это означает, что экземпляр будет доступен для всех запросов в рамках одной сессии. Например:
```
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION)
public class MySessionBean {
    public MySessionBean() {
        System.out.println("Создан экземпляр MySessionBean для HTTP-сессии");
    }
}
```
Все запросы в рамках одной сессии будут использовать один и тот же экземпляр MySessionBean.
Global Session: Эта область видимости используется в портлетах и создается для каждой глобальной сессии. Она редко используется в обычных веб-приложениях.

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

44.`Custom Bean Scopes`

В Spring Framework, помимо стандартных областей видимости бинов, таких как Singleton и Prototype, вы можете создавать собственные области видимости (Custom Bean Scopes). Это может быть полезно, когда вам нужно управлять жизненным циклом бинов в специфических условиях, которые не охватываются стандартными областями видимости.

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

Для создания пользовательской области видимости вам нужно реализовать интерфейс Scope и зарегистрировать его в контексте приложения. Рассмотрим пример, в котором мы создадим область видимости, которая будет создавать бины только в определённый момент времени, например, при каждом вызове определённого метода.

Создание класса пользовательской области видимости:

public class MyCustomScope implements Scope {
    // Реализация методов интерфейса Scope
}

Реализация методов интерфейса Scope:

public class MyCustomScope implements Scope {
    // Реализация методов интерфейса Scope
}

Зарегистрирование области видимости в контексте приложения:

// Регистрация области видимости в контексте приложения

45.`Web Bean Scopes`

46.`Prototype Bean Scope`

`lesson 10. Lifecycle Callbacks`

47.`Измененный Bean Lifecycle`

48.`Initialization callbacks`

49.`Destruction callbacks`

`lesson 11. Injection from Properties Files`

50.`Зачем использовать properties files`

51.`Создание файла application.properties`

52.`PropertySourcesPlaceholderConfigurer bean`

53.`Expression Language (EL)`

54.`Spring Expression Language (SpEL)`

55.`SpEL документация`

56.`System properties`

`lesson 12. BeanFactoryPostProcessor (BFPP)`

57.`Интерфейс BeanFactoryPostProcessor`

58.`Как работает PropertySourcesPlaceholderConfigurer`

59.`Измененный Bean Lifecycle`

60.`Метод isAssignableFrom`

`lesson 13. Custom BeanFactoryPostProcessor`

61.`Создание собственных BeanFactoryPostProcessor`

62.`Интерфейс Ordered`

63.`Интерфейс PriorityOrdered`

3.`Annotation-based Configuration`

`lesson 14. Annotation-based Configuration`

64.`Подключение зависимости jakarta annotation api`

65.`Аннотации @PostConstruct и @PreDestroy`

66.`Класс CommonAnnotationBeanPostProcessor`

67.`context:annotation-config xml element`

`lesson 15. BeanPostProcessor (BPP)`

68.`Интерфейс BeanPostProcessor`

69.`Bean Lifecycle (final version)`

70.`Интерфейс Aware`

71.`Класс ApplicationContextAwareProcessor`

`lesson 16. Custom BeanPostProcessor. Часть 1`

72.`Создание своей аннотации @InjectBean`

73.`Создание InjectBeanPostProcessor`

74.`Утилитный класс ReflectionUtils`

75.`Тестирование InjectBeanPostProcessor`

`lesson 17. Custom BeanPostProcessor. Часть 2`

76.`Создание аннотации @Transaction`

77.`Создание CrudRepository`

78.`Создание TransactionBeanPostProcessor`

79.`Тестирование TransactionBeanPostProcessor`

80.`Корректируем TransactionBeanPostProcessor`

81.`Создание AuditingBeanPostProcessor`

`lesson 18. @Autowired & @Value`

82.`Аннотация @Autowired`

83.`Аннотация @Resource`

84.`Решение конлифкта бинов. @Qualifier`

85.`Collection injection`

86.`Properties injection. @Value`

`lesson 19. Classpath Scanning`

87.`context:component-scan. Аннотации @Component`

88.`Замена бинов из xml на @Component`

89.`Тестирование функционала`

`lesson 20. Bean Definition Readers`

90.`Component Scan classes`

91.`Bean Definition Readers`

92.`Класс ComponentScanBeanDefinitionParser`

93.`Класс AnnotatedBeanDefinitionReader`

`lesson 21. Type Filters`

94.`Атрибут annotation-config`

95.`Атрибут name-generator`

96.`Атрибут resource-pattern`

97.`Атрибут scoped-proxy`

98.`Атрибут scope-resolver`

99.`Атрибут use-default-filters`

100.`5 type filters`

101.`Custom filters`

`lesson 22. @Scope`

102.`Атрибут scope-resolver`

103.`Класс AnnotationScopeMetadataResolver`

104.`Аннотация @Scope`

`lesson 23. JSR 250, JSR 330`

105.`Аббревиатура JSR`

106.`JSR 250`

107.`JSR 330`

108.`Класс Jsr330ScopeMetadataResolver`

4.`Java-based Configuration`

`lesson 24. Java-based Configuration`

109.`Класс ConfigurationClassBeanDefinitionReader`

110.`Создание ApplicationConfiguration. @Configuration`

111.`Аннотация @PropertySource`

112.`Аннотация @ComponentScan`

113.`Класс AnnotationConfigApplicationContext`

`lesson 25. @Import & @ImportResource`

114.`Класс AnnotationConfigApplicationContext`

115.`Аннотация @ImportResource`

116.`Аннотация @Import`

`lesson 26. @Bean. Часть 1`

117.`Аннотация @Bean`

118.`Тестирование Java конфигурации`

119.`Свойства аннотации @Bean`

120.`Аннотация @Scope с @Bean`

121.`Внедрение зависимостей с @Bean`

122.`Конфликт имен @Bean и @Component`

`lesson 27. @Bean. Часть 2`

123.`3-ий вариант внедрения зависимостей в @Bean`

124.`Cglib proxy в @Configuration`

125.`Свойство proxyBeanMethods в @Configuration`

126.`@Bean создаются через паттерн Service Locator`

`lesson 28. Profiles`

127.`Environment Bean`

128.`Аннотация @Profile`

129.`Активация profiles через properties`

130.`Активация profiles через ApplicationContext`

5.`Event Listeners`

`lesson 29. Event Listeners. Часть 1`

131.`Шаблон проектирования Listener`

132.`Создание события (Event)`

133.`Создание слушателя событий (Listener). @EventListener`

134.`Реализация логики для отправки события`

`lesson 30. Event Listeners. Часть 2`

135.`Bean ApplicationEventPublisher`

136.`Тестирование слушателей событий`

137.`Listeners order`

138.`Listeners conditions`

6.`Spring Boot`

`lesson 31. Spring Boot. Введение`

139.`Spring modules`

140.`Spring Data Configuration`

141.`Modules Auto Configuration`

142.`Conditions`

143.`Spring Boot Starters`

144.`Dependency Management`

145.`How to build Spring Boot Application`

`lesson 32. @Conditional`

146.`Аннотация @Conditional`

147.`Класс Condition`

148.`Custom JpaCondition`

149.`Тестирование JpaCondition`

150.`Аннотация @Profile`

151.`Другие @Condition аннотации`

`lesson 33. Spring Boot. Настройка проекта`

152.`Spring Boot Gradle Plugin`

153.`Spring Dependency Management Plugin`

154.`spring-boot-starter`

155.`Run Spring Boot Application`

156.`Autogenerated Spring Boot Project`

157.`Maven spring-boot-starter-parent pom`

`lesson 34. @SpringBootApplication`

158.`Структура Spring Boot приложения`

159.`Что делает метод SpringApplication.run`

160.`Аннотация @SpringBootApplication`

161.`Аннотация @SpringBootConfiguration`

162.`Аннотация @ComponentScan`

163.`Аннотация @PropertySource`

164.`Аннотация @EnableAutoConfiguration`

`lesson 35. Lombok`

165.`Подключение Lombok`

166.`Gradle Lombok Plugin`

167.`IntelliJ IDEA Lombok Plugin`

168.`Аннотации Lombok`

169.`Файл lombok.config`

`lesson 36. Properties`

170.`Файл spring.properties`

171.`Externalized Configuration`

172.`Profile-specific properties`

173.`Spring program arguments & VM options`

174.`Property Placeholders & Default values`

175.`spring.config.location`

`lesson 37. Yaml format`

176.`YAML - Yet Another Markup Language`

177.`Класс YamlPropertiesFactoryBean`

178.`Приоритет properties vs yaml`

179.`Переписывание application.properties на yaml`

`lesson 38. @ConfigurationProperties`

180.`Класс JpaProperties`

181.`Класс DatabaseProperties`

182.`Аннотация @ConfigurationProperties`

183.`Аннотация @ConfigurationPropertiesScan`

184.`Immutable DatabaseProperties`

185.`DatabaseProperties as record`

186.`Property key names`

`7. Logging Starter`

`lesson 39. Logging Starter`

190.`Application as a Black Box`

191.`Logging libraries`

192.`Log Levels`

193.`spring-boot-starter-logging dependency`

194.`Аннотация @Slf4j`

195.`Delombok annotations`

196.`Формат логов по умолчанию`

197.`logging.* properties`

`lesson 40. Logback Configuration`

198.`Logback default xml configs`

199.`File Output`

200.`Custom log configuration`

`8. Test Starter`

`lesson 41. Test Starter`

201.`Подключение spring-boot-starter-test`

202.`Транзитивные зависимости spring-boot-starter-test`

203.`Зависимость spring-test`

204.`Зависимость spring-boot-test`

205.`Зависимость spring-boot-test-autoconfigure`

206.`Пример написания Unit тестов`

207.`Java Gradle Plugin tasks relationship`

`lesson 42. Integration Testing. Part 1`

208.`Основные цели Spring Integration Testing`

209.`Жизненный цикл тестов`

210.`JUnit 5 Extension Model`

211.`TestContext Framework`

212.`SpringExtension source code`

`lesson 43. Integration Testing. Part 2`

213.`Создание CompanyServiceIT`

214.`SpringExtension via @ExtendWith`

215.`Аннотация @ContextConfiguration`

216.`Аннотация @TestPropertySource`

217.`Класс ApplicationContextInitializer`

218.`Аннотация @SpringBootTest`

219.`Написание первого интеграционного теста`

220.`Класс DependencyInjectionTestExecutionListener`

`lesson 44. Integration Testing. Part 3`

221.`Аннотация @ActiveProfiles`

222.`Custom Test Annotations`

223.`Аннотация @TestConstructor`

224.`Замена @TestConstructor на spring.properties`

`lesson 45. Context Caching`

225.`Создание нескольких ApplicationContext в тестах`

226.`Аннотации @MockBean и @SpyBean`

227.`Класс MockitoTestExecutionListener`

228.`Аннотация @TestConfiguration`

229.`Аннотация @DirtiesContext`

#9. Data JPA Starter

`lesson 46. Data JPA Starter. Введение`

230.`Чего не хватало в Hibernate`

231.`Установка PostgreSQL`

232.`Установка Docker`

233.`Postgres Docker Image`

234.`Подключение к postgres из IntelliJ IDEA`

`lesson 47. Data JPA Starter. Подключение`

235.`Подключение spring-boot-starter-data-jpa`

236.`Зависимости spring-boot-starter-data-jpa`

237.`Класс HibernateJpaAutoConfiguration`

238.`Настройка spring.datasource и spring.jpa properties`

239.`Тестирование приложения`

`lesson 48. Hibernate Entities`

240.`UML диаграмма выполненных sql скриптов`

241.`Создание сущности Company`

242.`Создание коллекции locales (ElementCollection)`

243.`Создание сущности User`

244.`Создание сущности Payment`

245.`Создание сущности Chat`

246.`Создание сущности UserChat`

247.`Проверка маппинга сущностей через hbm2ddl.auto`

248.`Аннотация @EntityScan`

`10. Data JPA Transactions`

`lesson 49. @Transactional. TestContext`

249.`Общая структура работы с TransactionManager`

250.`Создание CompanyRepository IT`

251.`Аннотации @Transactional из Jakarta EE и Spring`

252.`Класс TransactionalTestExecutionListener`

253.`Аннотации @Commit и @Rollback`

`lesson 50. TransactionAutoConfiguration`

254.`Класс TransactionAutoConfigurationКак происходит обработка транзакций в proxy`

255.`Аннотация @Transactional и Cglib proxy`

256.`Как работает Cglib proxy с TransactionManager`

257.`Как подключить механизм транзакций внутри объекта (не proxy)`

258.`Механизм транзакций между несколькими Cglib proxy`

`lesson 51. @Transactional Settings`

259.`Свойства @Transactional. transactionManager`

260.`Transaction propagation`

261.`Transaction propagation резюме`

262.`Transaction isolation`

263.`Transaction timeout`

264.`ReadOnly transaction`

265.`Transaction rollbackFor & rollbackForClassName`

266.`Transaction noRollbackFor & noRollbackForClassName`

`lesson 52. Manual Transactions`

267.`Свойства объекта TransactionTemplate`

268.`Функционал TransactionTemplate`

269.`Обработка checked exceptions`

270.`Взаимодействие TransactionTemplate с другими Proxy`

271.`Вынесение @Transactional в @IT`

`11. Data JPA Repositories`

169 KiB Raw Blame History Unescape Escape

Содержание

3. Annotation-based Configuration

4. Java-based Configuration

5. Event Listeners

6. Spring Boot

169 KiB

Raw Blame History Unescape Escape