Java for Beginner

Всем доброе утро!🔆

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

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

Приходите, будет интересно!✌️

141 views04:55

Java for Beginner

Встреча создана - подключаемся!🤌

https://telemost.yandex.ru/j/98297981728791

143 views12:59

Java for Beginner

Пишем свою нейросеть! Подробные разъяснения и примеры кода. Встреча от 27.10.2024

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

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

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

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

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

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

146 viewsedited 15:55

Java for Beginner

Контекст Spring: ApplicationContext и BeanFactory

Spring Container

В основе любого приложения на Spring лежит так называемый Spring Container, который управляет жизненным циклом бинов, их созданием, конфигурированием и внедрением зависимостей. Два основных интерфейса, отвечающих за работу контейнера в Spring, — это BeanFactory и ApplicationContext. Они оба обеспечивают возможность создания и управления объектами (бинами), но существуют важные различия в их функциональности и использовании.

Что такое BeanFactory?

BeanFactory — это самый базовый контейнер Spring, отвечающий за создание, управление и доставку бинов. Он ленивый, то есть создаёт бины только тогда, когда они нужны (по запросу), что делает его очень эффективным с точки зрения потребления ресурсов. Однако BeanFactory не предоставляет многих дополнительных возможностей, таких как управление событиями, автоматическое связывание бинов (autowiring), или интеграция с аспектно-ориентированным программированием (AOP).

Ключевые особенности BeanFactory:

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

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

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class BeanFactoryExample {

    public static void main(String[] args) {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));

        MyService myService = (MyService) factory.getBean("myService");
        myService.doSomething();
    }
}
В этом примере XmlBeanFactory загружает конфигурацию из файла beans.xml, который находится в classpath, и затем извлекает бин myService из контейнера.

Что такое ApplicationContext?

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

Ключевые возможности ApplicationContext:

Автоматическое связывание (autowiring): Spring может автоматически внедрять зависимости без необходимости указывать их явно.
Управление жизненным циклом бинов: Поддерживает начальные и финальные методы для бинов, что упрощает настройку.
Международная поддержка (i18n): Позволяет работать с сообщениями, адаптированными под разные языки и регионы.
Поддержка событий: Включает систему публикации и обработки событий внутри приложения.
Интеграция с AOP: Поддерживает аспектно-ориентированное программирование.

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

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

public class ApplicationContextExample {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}
В этом примере ClassPathXmlApplicationContext загружает тот же файл конфигурации, что и в случае с BeanFactory, но предоставляет больше функциональности за счёт работы с ApplicationContext.

#Java #Training #Spring #BeanFactory #ApplicationContext

117 views05:29

Java for Beginner

Основные различия между BeanFactory и ApplicationContext

Инициализация бинов:
BeanFactory: Ленивая инициализация — бины создаются только по запросу.
ApplicationContext: Все синглтоны создаются сразу при запуске контейнера.

Управление событиями:
BeanFactory: Не поддерживает события.
ApplicationContext: Поддерживает публикацию и обработку событий внутри контейнера.

Международная поддержка (i18n):
BeanFactory: Не поддерживает.
ApplicationContext: Поддерживает работу с локализованными сообщениями.

Интеграция с AOP:
BeanFactory: Ограничена в функциональности аспектов.
ApplicationContext: Полностью поддерживает AOP.

Автоматическое связывание (autowiring):
BeanFactory: Требует явной настройки.
ApplicationContext: Поддерживает автосвязывание.

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

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

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

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

Примеры событий в ApplicationContext

Одна из ключевых возможностей ApplicationContext — это поддержка событий. Вы можете создать собственные события и обработчики для их обработки.

Создадим событие:

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }

    public String toString() {
        return "Мое кастомное событие!";
    }
}

Создадим обработчик:

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {

    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("Получено событие: " + event);
    }
}

Опубликуем событие:

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

@Component
public class EventPublisher {

    @Autowired
    private ApplicationEventPublisher publisher;

    public void publishCustomEvent() {
        CustomEvent event = new CustomEvent(this);
        publisher.publishEvent(event);
    }
}
Таким образом, Spring предоставляет мощный механизм для работы с событиями через ApplicationContext.

#Java #Training #Spring #BeanFactory #ApplicationContext

118 views05:29

Java for Beginner

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

import java.util.*;

public class Task281024 {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<>();
        set.add("A");
        set.add("B");
        set.add("A");
        set.add(null);
        set.add("C");
        set.add(null);
        
        for (String s : set) {
            System.out.print(s + " ");
        }
    }
}

#Tasks

118 views08:44

Java for Beginner

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

Anonymous Quiz

18 voters120 views08:48

Java for Beginner

Хорошее сравнение 🤪😂😂😂

https://t.me/Java_for_beginner_dev

#Mems

119 views10:19

Java for Beginner

Способы загрузки контекста в Spring

Загрузка контекста в Spring

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

1. ClassPathXmlApplicationContext

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

Пример загрузки конфигурации через ClassPathXmlApplicationContext

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

public class ClassPathContextExample {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}
Здесь XML-файл beans.xml должен находиться в директории ресурсов (src/main/resources).

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

2. FileSystemXmlApplicationContext

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

Пример загрузки конфигурации через FileSystemXmlApplicationContext

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

public class FileSystemContextExample {

    public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext("/path/to/beans.xml");

        MyService myService = (MyService) context.getBean("myService");
        myService.doSomething();
    }
}

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

3. AnnotationConfigApplicationContext — для конфигурации с помощью аннотаций

AnnotationConfigApplicationContext — это более современный способ загрузки контекста в Spring, основанный на использовании Java-конфигураций и аннотаций. Вместо XML-файлов для конфигурации используются Java-классы с аннотациями, такими как @Configuration, @Bean, и @ComponentScan.

Пример конфигурации через аннотации с использованием AnnotationConfigApplicationContext

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

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

public class AnnotationConfigExample {

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

        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}
В этом примере мы создаём конфигурационный класс AppConfig, помеченный аннотацией @Configuration, и регистрируем метод myService() с помощью аннотации @Bean. AnnotationConfigApplicationContext загружает эту конфигурацию и предоставляет необходимые бины.

Преимущества:
Чистота и компактность конфигурации.
Легче тестировать и поддерживать, так как конфигурация написана на Java.
Хорошо подходит для современных проектов, использующих аннотации.

#Java #Training #Spring #Load_context

102 views14:19

Java for Beginner

4. GenericApplicationContext — для комбинированного использования различных типов конфигурации

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

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

import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class GenericContextExample {

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();

        // Добавляем конфигурацию через XML
        new ClassPathXmlApplicationContext("beans.xml", context);
        
        // Добавляем конфигурацию через аннотации
        new AnnotationConfigApplicationContext(AppConfig.class);

        context.refresh();

        MyService myService = context.getBean(MyService.class);
        myService.doSomething();
    }
}
В этом примере мы объединяем загрузку конфигурации из XML (beans.xml) и Java-аннотаций (AppConfig.class) с помощью GenericApplicationContext. Это мощный способ работы с несколькими типами конфигураций одновременно.

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

Когда использовать каждый способ загрузки контекста?

ClassPathXmlApplicationContext — если конфигурация хранится в ресурсах проекта и должна быть доступна через classpath.
FileSystemXmlApplicationContext — если конфигурационные файлы находятся за пределами приложения и вам нужно динамически указывать путь к ним.
AnnotationConfigApplicationContext — предпочтителен для современных приложений, использующих Java-конфигурации и аннотации.
GenericApplicationContext — идеален для приложений, где требуется объединить различные типы конфигурации (XML, Java-аннотации).

#Java #Training #Spring #Load_context

79 views14:19

Java for Beginner

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

Задача по Spring. Различия между BeanFactory и ApplicationContext. Сложность легкая.

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

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

public class Task281024_2 {
    public static void main(String[] args) {
        BeanFactory beanFactory = new AnnotationConfigApplicationContext(Config2810.class);
        ApplicationContext appContext = new AnnotationConfigApplicationContext(Config2810.class);

        Bean2810 beanFromFactory = (Bean2810) beanFactory.getBean("bean2810");
        Bean2810 beanFromContext = (Bean2810) appContext.getBean("bean2810");

        System.out.println(beanFromFactory == beanFromContext);
    }
}

@Configuration
class Config2810 {
    @Bean
    public Bean2810 bean2810() {
        return new Bean2810();
    }
}

class Bean2810 {}

#TasksSpring

95 views14:59

Java for Beginner

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

Anonymous Quiz

Исключение времени выполнения

Java

7 voters104 views15:04

Java for Beginner

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

1. Контекст задачи:

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

2. Код задачи:

В задаче создаются два разных контейнера Spring:
BeanFactory инициализируется через AnnotationConfigApplicationContext.
ApplicationContext инициализируется через тот же класс AnnotationConfigApplicationContext.
Конфигурационный класс Config2810 предоставляет бин типа Bean2810, который регистрируется в обоих контейнерах.

3. Ключевой момент:

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

В строках:

Bean2810 beanFromFactory = (Bean2810) beanFactory.getBean("bean2810");
Bean2810 beanFromContext = (Bean2810) appContext.getBean("bean2810");
вызывается метод getBean для получения бина из каждого контейнера.

Результат: Проверка на идентичность с помощью оператора == возвращает false, поскольку BeanFactory и ApplicationContext создают разные экземпляры Bean2810.

4. Аннотации и конфигурация:

В этой задаче конфигурация бинов осуществляется с использованием аннотации @Bean, которая указывает Spring создать и управлять бином через указанный метод. Это не требует XML-файлов, что упрощает код, делая его более современным и наглядным.

5. Основные выводы задачи:

BeanFactory vs ApplicationContext: Хотя оба этих контейнера могут управлять бинами, их поведения различаются:
BeanFactory создаёт бины лениво, т.е. при первом запросе через getBean().
ApplicationContext инициализирует бины сразу при запуске контекста.
При использовании одного и того же конфигурационного класса каждый контейнер создаёт свои экземпляры, которые не являются одинаковыми объектами.

#Solution_TasksSpring

95 views15:29

Java for Beginner

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

В основе работы любого приложения Spring лежит контейнер IoC (Inversion of Control), который управляет созданием, конфигурированием и управлением бинов. Контекст приложения (ApplicationContext) — это более продвинутый контейнер по сравнению с BeanFactory, который не только управляет бинами, но и предоставляет множество дополнительных возможностей. Понимание жизненного цикла ApplicationContext — это ключевой элемент при построении приложения с использованием Spring.

1. Что такое ApplicationContext?

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

Пример того, как выглядит структура наследования ApplicationContext:
BeanFactory — базовый интерфейс для управления бинами.

ApplicationContext — расширяет BeanFactory, добавляя такие возможности, как:
Автоматическая регистрация событий;
Интеграция с AOP (Aspect-Oriented Programming);
Поддержка аннотаций.

2. Этапы жизненного цикла ApplicationContext

Жизненный цикл ApplicationContext можно разделить на несколько этапов:

2.1. Создание ApplicationContext

Первым шагом является создание объекта контекста. В зависимости от типа конфигурации вы можете выбрать нужный вам тип контекста, например, ClassPathXmlApplicationContext, AnnotationConfigApplicationContext или FileSystemXmlApplicationContext.

Пример создания контекста через XML:

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        MyService myService = context.getBean(MyService.class);
        myService.doWork();
    }
}

Пример создания контекста через аннотации:

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

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doWork();
    }
}

2.2. Чтение конфигурации

После создания контекста Spring загружает конфигурацию (XML или Java-классы). В этом процессе Spring сканирует конфигурационные файлы или аннотированные классы и регистрирует бины.

2.3. Создание и инициализация бинов

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

2.4. Внедрение зависимостей (Dependency Injection)

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

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

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

public class MyService {

    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    public void doWork() {
        myRepository.saveData();
    }
}

#Java #Training #Spring #ApplicationContext_LifeCicle

97 views05:29

Java for Beginner

2.5. Готовность к работе

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

2.6. Закрытие контекста

Когда работа приложения завершается, контекст закрывается. Это может происходить при завершении работы программы или вручную. При закрытии контекста вызываются методы, помеченные аннотацией @PreDestroy, для завершения работы и освобождения ресурсов.

Пример закрытия контекста вручную:

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

public class App {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.doWork();

        // Закрытие контекста вручную
        context.close();
    }
}

2.7. Уничтожение бинов

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

3. События в жизненном цикле ApplicationContext

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

Это:
ContextRefreshedEvent — событие генерируется после того, как все бины были инициализированы и контекст готов к работе.
ContextClosedEvent — генерируется при закрытии контекста.
ContextStartedEvent и ContextStoppedEvent — для запуска и остановки контекста.

Пример слушателя событий:

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class ContextStartedListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("Контекст был обновлён и готов к использованию.");
    }
}

#Java #Training #Spring #ApplicationContext_LifeCicle

106 views05:29

Java for Beginner

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

public class Task291024_1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 5;
        int result = (a + b) * c / 2;
        System.out.println("Result: " + result);
    }
}

#Tasks

113 viewsedited 08:44

Java for Beginner

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

Anonymous Quiz

18 voters116 views08:48

Java for Beginner

😱 а я бы попробовал🤪😂

https://t.me/Java_for_beginner_dev

#Mems

116 viewsedited 10:36

Java for Beginner

Построение приложения с использованием Java-конфигурации в Spring

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

1. Java-конфигурация в Spring

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

1.1. Создание конфигурационного класса
Чтобы начать использование Java-конфигурации, необходимо создать класс с аннотацией @Configuration, который будет содержать все необходимые бины.

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

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

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService(myRepository());
    }

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }
}
Здесь метод myService() создает экземпляр класса MyService, а метод myRepository() создает и возвращает объект класса MyRepository. Таким образом, Spring может управлять этими объектами как бинами и внедрять их в зависимости.

1.2. Запуск приложения с Java-конфигурацией
Для запуска приложения с Java-конфигурацией используется AnnotationConfigApplicationContext, который загружает конфигурационный класс.

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

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

        MyService myService = context.getBean(MyService.class);
        myService.doWork();
    }
}
В этом примере мы загружаем конфигурацию из AppConfig.class и получаем необходимые бины с помощью метода context.getBean().

#Java #Training #Spring #Spring_Application

115 views14:05

Java for Beginner

2. Аннотации в Java-конфигурации

Java-конфигурация активно использует аннотации, такие как @Bean, @Autowired, @Component, @Configuration, которые помогают упростить создание бинов и внедрение зависимостей.

2.1. Аннотация @Configuration
Аннотация @Configuration указывает Spring, что данный класс содержит определения бинов. Это аналог XML-конфигурационного файла.

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

2.3. Аннотация @Component
Аннотация @Component применяется к классу и указывает, что этот класс является бин-компонентом. Это позволяет Spring автоматически обнаруживать и регистрировать этот бин с помощью механизма сканирования.

import org.springframework.stereotype.Component;

@Component
public class MyRepository {
    public void saveData() {
        System.out.println("Данные сохранены");
    }
}

2.4. Аннотация @Autowired
Аннотация @Autowired указывает Spring, что нужно автоматически внедрить зависимость.

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

@Component
public class MyService {

    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    public void doWork() {
        myRepository.saveData();
    }
}

3. Преимущества использования Java-конфигурации

Использование Java-конфигурации имеет несколько преимуществ:
Читаемость и поддерживаемость: Конфигурация находится в одном месте, прямо в коде.
Сила типизации: Java-код компилируется, что позволяет избежать ошибок, связанных с опечатками, как это возможно в XML.
Тестируемость: Java-конфигурации проще тестировать, так как вы можете загружать их в тестах.
Интеграция с современными фреймворками: Java-конфигурация хорошо сочетается с другими технологиями, такими как Spring Boot.

4. Комбинированная конфигурация

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

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

@Configuration
@ImportResource("classpath:beans.xml")
public class AppConfig {
    // Дополнительные Java-бины могут быть определены здесь
}

#Java #Training #Spring #Spring_Application

121 views14:05

About

Blog

Apps

Platform