Java for Beginner
@Java_for_beginner_dev
672 subscribers
540 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
About
Blog
Apps
Platform
Join
Java for Beginner
672 subscribers
Java for Beginner
Специфика работы с аннотацией @Repository в Spring

Аннотация @Repository в Spring используется для обозначения классов, которые занимаются доступом к данным (обычно к базе данных). Это еще одна специализированная аннотация, расширяющая функциональность @Component, и применяется к классам, реализующим паттерн DAO (Data Access Object).

1. @Repository

Аннотация @Repository используется для маркировки классов, которые взаимодействуют с базами данных или другими внешними источниками данных. Она является частью архитектуры Spring Data и служит для автоматической регистрации DAO-классов в контексте Spring.

Главная цель @Repository — это семантическое обозначение уровня доступа к данным, которое не только помогает разработчикам, но и предоставляет Spring возможность обрабатывать специфичные для работы с базами данных исключения. Spring автоматически преобразует исключения низкого уровня (например, SQLException) в свои собственные, что облегчает обработку ошибок.

2. Пример использования @Repository

Рассмотрим пример, как с помощью @Repository можно обозначить класс, работающий с базой данных:
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {

    public User findById(int id) {
        // Код для взаимодействия с базой данных, например, через JDBC или JPA
        return new User(id, "John Doe");
    }
}
В этом примере UserRepository — это класс, который занимается поиском данных о пользователях в базе данных. Благодаря аннотации @Repository, Spring автоматически зарегистрирует этот класс как бин, и он станет доступным для внедрения зависимостей.


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

Использование аннотации @Repository предоставляет несколько преимуществ
Единая обработка исключений: Spring использует @Repository для автоматического преобразования исключений базы данных в свои собственные, что делает код более независимым от конкретной реализации доступа к данным.
Логическая организация: Аннотация помогает четко обозначить уровень доступа к данным, разделяя его от бизнес-логики и представления.
Совместимость с различными технологиями доступа к данным: @Repository может применяться для классов, использующих различные подходы к работе с базой данных, такие как JDBC, JPA, Hibernate и другие.

#Java #Training #Spring #Repository
111 views
Java for Beginner
4. Обработка исключений с помощью @Repository

Одной из важных функций аннотации @Repository является автоматическое преобразование исключений. Например, если в вашем DAO-классе возникнет SQLException, Spring автоматически преобразует его в более понятное исключение уровня Spring, например, DataAccessException. Это позволяет избавиться от необходимости явно обрабатывать специфичные исключения на уровне базы данных.

Пример с обработкой исключений:
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Repository;

@Repository
public class ProductRepository {

    public Product findById(int id) throws DataAccessException {
        try {
            // Логика доступа к базе данных
            return new Product(id, "Product Name");
        } catch (Exception e) {
            // Исключение будет автоматически обработано Spring
            throw new DataAccessException("Ошибка при доступе к данным") {};
        }
    }
}
Здесь мы видим, что при возникновении ошибки в методе findById, Spring сам может преобразовать её в DataAccessException.


5. Использование @Repository с JPA и Hibernate

Аннотация @Repository часто используется в комбинации с фреймворками для работы с базами данных, такими как JPA (Java Persistence API) и Hibernate. В этом случае Spring Data JPA предоставляет удобный механизм для создания репозиториев без необходимости писать код для CRUD-операций вручную.

Пример репозитория с использованием JPA:
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CustomerRepository extends JpaRepository<Customer, Long> {
    // Spring Data JPA автоматически сгенерирует методы для операций с базой данных
}
В данном примере интерфейс CustomerRepository автоматически получает все необходимые методы для работы с базой данных благодаря расширению JpaRepository. Spring Data JPA автоматически создаст реализацию этого интерфейса.


#Java #Training #Spring #Repository
95 views
Java for Beginner
Что выведет код?

Задача по Spring. @Component и @Service. Сложность легкая.

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

public class Main301024_2 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config3010.class);
        Client3010 client = context.getBean(Client3010.class);
        client.process();
    }
}

@Configuration
@ComponentScan
class Config3010 {}

@Component
class Client3010 {
    private final Service3010 service;

    @Autowired
    public Client3010(Service3010 service) {
        this.service = service;
    }

    public void process() {
        service.execute3010();
    }
}

@Service
class Service3010 {
    public void execute3010() {
        System.out.println("Service executed");
    }
}


#TasksSpring
111 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
14%
Ошибка компиляции
0%
Пустой вывод
7%
Исключение времени выполнения
79%
Service executed
0%
Java forever
14 voters104 views
Java for Beginner
Подробный разбор решения задачи Task301024_2

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

В задаче исследуются аннотации Spring — @Component и @Service, которые используются для создания и управления бинами в Spring-контексте. Эти аннотации автоматически регистрируют классы как бины, которые затем могут быть внедрены в другие компоненты с помощью механизма инверсии управления (IoC).

Задача демонстрирует, как Spring управляет бинами и внедряет зависимости через аннотацию @Autowired, используя автоматическую конфигурацию с помощью аннотации @ComponentScan.

2. Описание кода:

Класс Main3010:
Основной класс программы создает ApplicationContext с использованием конфигурационного класса Config3010. Этот контекст сканирует пакет com.example на наличие компонентов, таких как Client3010 и Service3010.
Из контекста извлекается бин типа Client3010, и вызывается его метод process(), который вызывает внедренный метод сервиса.

Класс Config3010:
Этот класс помечен аннотацией @Configuration, что указывает на то, что он является источником определения бинов.
Аннотация @ComponentScan автоматически сканирует указанный пакет com.example на наличие классов с аннотациями @Component или @Service.

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

Класс Service3010:
Класс помечен аннотацией @Service, что регистрирует его как бин в контексте. Хотя @Service и @Component функционально идентичны, @Service используется для того, чтобы явно указать, что класс выполняет сервисную логику.

3. Механизм работы:

@Component и @Service: Оба эти класса регистрируются в контексте благодаря аннотации @ComponentScan, которая автоматически находит и загружает все классы, помеченные как компоненты. В данном случае, классы Client3010 и Service3010 становятся доступными в контексте.

@Autowired: Аннотация на конструкторе Client3010 автоматически внедряет зависимость от бина Service3010, когда создается объект Client3010. Это позволяет вызвать метод execute() у внедренного сервиса.

4. Результат выполнения:
Когда контекст создается и бин Client3010 запрашивается из контекста, его метод process() вызывает метод execute() у бина Service3010, который выводит строку:
Service executed

5. Выводы и ключевые моменты:
@Component vs @Service: Хотя аннотации функционально идентичны, @Service используется, чтобы подчеркнуть, что класс предназначен для сервисной логики, а @Component — более общий способ указать, что это Spring-компонент.

Автоматическое сканирование пакетов: Благодаря аннотации @ComponentScan, Spring автоматически находит и регистрирует все компоненты, что упрощает конфигурацию.

Инъекция зависимостей: Spring автоматически связывает бины через аннотацию @Autowired, что демонстрирует мощный механизм инверсии управления, при котором зависимости управляются контейнером Spring.

#Solution_TasksSpring
102 views
Java for Beginner
Способы работы с внешними конфигурациями в Spring: application.properties и application.yml

Spring Framework предоставляет мощные механизмы для работы с конфигурационными файлами, которые позволяют удобно управлять настройками приложения без необходимости перекомпиляции кода. В основном используются два формата файлов для хранения конфигураций — это application.properties и application.yml. Оба файла позволяют задавать параметры приложения, такие как настройки подключения к базе данных, порты сервера и другие ключевые свойства.

1. Работа с application.properties

Формат application.properties является традиционным для Spring и состоит из набора пар ключ-значение. Этот файл обычно размещается в папке src/main/resources и загружается автоматически при старте приложения Spring Boot.

1.1. Пример application.properties
# Настройки сервера
server.port=8081

# Настройки базы данных
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# Логирование
logging.level.org.springframework=INFO


1.2. Чтение свойств из application.properties

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

Пример внедрения значения из application.properties:
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Value("${server.port}")
    private int serverPort;

    public void printPort() {
        System.out.println("Порт сервера: " + serverPort);
    }
}
В этом примере значение из параметра server.port будет внедрено в переменную serverPort.


1.3. Использование @ConfigurationProperties

Для работы с большим количеством связанных настроек можно использовать аннотацию @ConfigurationProperties, которая автоматически связывает свойства из конфигурационного файла с полями Java-класса.

Пример использования @ConfigurationProperties:
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {

    private String url;
    private String username;
    private String password;

    // Геттеры и сеттеры
}
Здесь класс DataSourceConfig автоматически связывается с параметрами, которые начинаются с префикса spring.datasource в файле application.properties.


#Java #Training #Spring #properties
115 views
Java for Beginner
2. Работа с application.yml
Формат YAML (.yml) является альтернативой для application.properties. Он предлагает более читаемый синтаксис и иерархическую структуру для организации настроек. Формат YAML особенно удобен при работе с вложенными конфигурациями.

2.1. Пример application.yml
server:
  port: 8081

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

logging:
  level:
    org.springframework: INFO


2.2. Чтение свойств из application.yml

Чтение свойств из YAML-файла происходит так же, как и из application.properties, с помощью аннотации @Value или @ConfigurationProperties.

Пример использования аннотации @Value с application.yml:
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Value("${server.port}")
    private int serverPort;

    public void printPort() {
        System.out.println("Порт сервера: " + serverPort);
    }
}
Здесь значение параметра server.port из файла application.yml также будет внедрено в поле serverPort.


3. Профили в Spring для разных окружений

Spring поддерживает профили — это механизм, который позволяет задавать разные наборы конфигураций для различных сред (например, для разработки, тестирования, производства). Файлы конфигураций могут быть названы по шаблону application-{profile}.properties или application-{profile}.yml.

3.1. Пример использования профилей

Для активации профиля в Spring можно добавить соответствующий файл, например, application-dev.properties:
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/devdb


Аналогично можно создать файл application-prod.yml для боевого окружения:
server:
  port: 80
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/proddb


3.2. Активирование профиля

Чтобы указать Spring, какой профиль использовать, можно прописать его в application.properties:
spring.profiles.active=dev


Или через параметры запуска приложения:
java -jar myapp.jar --spring.profiles.active=prod


4. Использование внешних файлов конфигураций

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

Пример запуска с внешним файлом конфигурации:
java -jar myapp.jar --spring.config.location=file:/path/to/external/application.properties


#Java #Training #Spring #yml #yaml
109 viewsedited  
Java for Beginner
Что выведет код?

public class Task311024_1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        arr[2] = arr[4];
        arr[4] = 10;
        
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}


#Tasks
116 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
9%
1 2 10 4 5
64%
1 2 5 4 10
5%
1 2 5 6 10
23%
1 2 10 4 10
22 voters121 views
Java for Beginner
Ну что тут скажешь...🤷‍♂️🤪😂😂😂

https://t.me/Java_for_beginner_dev

#Mems
120 views
Java for Beginner
Валидация и валидационные аннотации в Spring

Валидация данных — это важная часть разработки любого приложения. Валидационные аннотации позволяют легко проверить входные данные, обеспечивая их корректность перед тем, как они попадут в логику приложения. Spring поддерживает валидацию с использованием Java Bean Validation API (JSR-303) и предоставляет аннотации для автоматической проверки данных.

1. Основы валидации в Spring

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

Для использования валидации в Spring необходимо добавить зависимость spring-boot-starter-validation в проект:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>


2. Основные валидационные аннотации

2.1. Аннотация @NotNull

Аннотация @NotNull проверяет, что значение поля не равно null.
import javax.validation.constraints.NotNull;

public class User {

    @NotNull(message = "Имя не должно быть пустым")
    private String name;

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


2.2. Аннотация @Size

Аннотация @Size используется для ограничения длины строки или размера коллекции.
import javax.validation.constraints.Size;

public class User {

    @Size(min = 3, max = 20, message = "Имя должно быть от 3 до 20 символов")
    private String name;

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


2.3. Аннотация @Email

Аннотация @Email проверяет, что значение соответствует формату email-адреса.
import javax.validation.constraints.Email;

public class User {

    @Email(message = "Неверный формат email")
    private String email;

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


2.4. Аннотация @Min и @Max

Эти аннотации проверяют минимальное и максимальное значение числового поля.
import javax.validation.constraints.Min;
import javax.validation.constraints.Max;

public class Product {

    @Min(value = 1, message = "Цена должна быть больше 0")
    @Max(value = 1000, message = "Цена не должна превышать 1000")
    private int price;

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


3. Пример валидации DTO в Spring

Предположим, у нас есть класс UserDTO, который представляет данные пользователя, получаемые через форму.
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.validation.constraints.Email;

public class UserDTO {

    @NotNull(message = "Имя не может быть пустым")
    @Size(min = 3, max = 50, message = "Имя должно быть от 3 до 50 символов")
    private String name;

    @NotNull(message = "Email не может быть пустым")
    @Email(message = "Неправильный формат email")
    private String email;

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


Теперь создадим REST-контроллер, который будет обрабатывать запросы на регистрацию пользователя.
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import org.springframework.http.ResponseEntity;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@Valid @RequestBody UserDTO user) {
        return ResponseEntity.ok("Пользователь успешно зарегистрирован");
    }
}
Здесь @Valid указывает Spring на необходимость выполнить валидацию объекта UserDTO перед тем, как продолжить выполнение метода. Если данные не пройдут проверку, Spring автоматически вернет ошибку 400 (Bad Request) с описанием нарушений.


#Java #Training #Spring #NotNull #Size #Email #Min #Max
102 views
Java for Beginner
4. Кастомные аннотации валидации

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

4.1. Создание кастомной аннотации

Определим аннотацию @UniqueEmail.
import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Documented
@Constraint(validatedBy = UniqueEmailValidator.class)
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface UniqueEmail {

    String message() default "Email уже используется";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}


Реализуем валидатор.
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class UniqueEmailValidator implements ConstraintValidator<UniqueEmail, String> {

    @Override
    public boolean isValid(String email, ConstraintValidatorContext context) {
        // Логика проверки уникальности email
        return !email.equals("existingemail@example.com");
    }
}


Используем нашу кастомную аннотацию.
public class UserDTO {

    @UniqueEmail
    private String email;

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


#Java #Training #Spring #NotNull #Size #Email #Min #Max
93 views
Java for Beginner
Что выведет код?

Задача по Spring. Аннотации @NotNull @Size @Email @Min @Max. Сложность легкая.

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

import jakarta.validation.ConstraintViolationException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;

public class Main311024_2 {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config3110.class);
        UserService3110 userService = context.getBean(UserService3110.class);

        try {
            userService.registerUser("Jo", "mai.ru", 15);
        } catch (ConstraintViolationException e) {
            System.out.println("Validation failed");
        }
    }
}

@Configuration
class Config3110 {
    @Bean
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        return new MethodValidationPostProcessor();
    }

    @Bean
    public UserService3110 userService3110() {
        return new UserService3110();
    }
}

@Component
@Validated
class UserService3110 {

    public void registerUser(
        @NotNull @Size(min = 3, message = "Name must be at least 3 characters") String name,
        @Email(message = "Email should be valid") String email,
        @Min(value = 16, message = "Age must be at least 16") int age) {

        System.out.println("User registered: " + name + ", " + email + ", " + age);
    }
}


#TasksSpring
108 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
11%
User registered: Jo, mai.ru, 15
0%
Исключение времени выполнения
11%
Пользователль зарегистрирован: Jo, mai.ru, 15
78%
Validation failed
9 voters100 views
Java for Beginner
Подробный разбор решения задачи Task311024_2

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

Эта задача исследует механизм валидации параметров метода в Spring с использованием аннотаций валидации из пакета jakarta.validation. Задача демонстрирует, как Spring обеспечивает автоматическую проверку аргументов метода с использованием аннотаций, таких как @NotNull, @Size, @Email и @Min, а также как обрабатываются ошибки валидации.

2. Ключевые элементы кода:

@Validated: Эта аннотация над классом UserService3110 активирует проверку параметров методов, аннотированных валидаторами.

Аннотации валидации:
@NotNull: Проверяет, что параметр не равен null.
@Size(min = 3): Проверяет, что строка содержит минимум 3 символа.
@Email: Проверяет, что строка соответствует формату корректного email.
@Min(16): Проверяет, что значение целого числа больше или равно 16.

Метод registerUser(): В этом методе применяются валидаторы для аргументов name, email и age. Если какой-либо из параметров не удовлетворяет условиям валидации, будет выброшено исключение ConstraintViolationException, которое можно перехватить.

3. Сценарий работы программы:

Программа создает контекст Spring с помощью класса AnnotationConfigApplicationContext, который сканирует конфигурационный класс Config3110 для создания бинов.
Контекст создает и регистрирует бин UserService3110, который помечен аннотацией @Validated, что активирует механизм валидации метода registerUser().
Затем вызывается метод registerUser() с некорректными значениями аргументов:
name = "Jo" — слишком короткое имя (меньше 3 символов), не проходит проверку аннотации @Size.
email = "mai.ru" — это некорректный email, не соответствует аннотации @Email.
age = 15 — значение меньше минимального значения 16, что нарушает условие аннотации @Min.
Поскольку все три параметра не проходят валидацию, Spring бросит исключение ConstraintViolationException.

4. Ожидаемый результат:

Исключение ConstraintViolationException будет перехвачено в блоке try-catch, и программа выведет в консоль:
Validation failed


5. Ключевые моменты и выводы:

Валидация параметров метода: Благодаря аннотации @Validated и встроенным валидаторам, Spring автоматически проверяет корректность передаваемых аргументов методов.
Обработка исключений: Ошибки валидации приводят к выбрасыванию исключения, которое можно перехватить и обработать в коде.
Конфигурация Spring: Класс Config3110 включает бин MethodValidationPostProcessor, который необходим для того, чтобы включить проверку аргументов методов.

#Solution_TasksSpring
107 views
Java for Beginner
@Import в Spring

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

1. Основные аспекты аннотации @Import

Аннотация @Import используется для импорта одной или нескольких конфигураций в основной конфигурационный класс. Это особенно полезно при работе с большими приложениями, где конфигурации могут быть разделены на модули, каждый из которых описывает свою часть приложения (например, доступ к данным, безопасность, бизнес-логика). Аннотация позволяет централизовать настройки, сохраняя при этом гибкость и упрощая управление зависимостями.

2. Пример использования @Import для импорта конфигураций

Рассмотрим, как можно использовать @Import, чтобы объединить несколько конфигураций в одном основном классе.

Шаг 1: Создание конфигурационного класса для базы данных
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }
}


Шаг 2: Создание конфигурации для сервиса
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ServiceConfig {

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


Шаг 3: Импорт конфигураций в основной конфигурационный класс

Теперь объединим классы DataSourceConfig и ServiceConfig с помощью @Import в основной конфигурации приложения.
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({DataSourceConfig.class, ServiceConfig.class})
public class AppConfig {
    // Основная конфигурация приложения
}
Таким образом, класс AppConfig становится главным конфигурационным классом, импортирующим DataSourceConfig и ServiceConfig. Spring автоматически распознает и зарегистрирует все бины из импортированных классов.


3. Импорт нескольких конфигураций с @Import

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

Пример импорта массива конфигураций:
@Import({DataSourceConfig.class, ServiceConfig.class, AnotherConfig.class})
public class MainConfig {
    // Основная конфигурация
}


#Java #Training #Spring #Import
116 views
Java for Beginner
4. Использование @Import для динамического подключения конфигураций

Существуют ситуации, когда необходимо подключить конфигурации в зависимости от условий. В таких случаях Spring позволяет использовать класс @ImportSelector для определения, какие конфигурации необходимо подключить.

Пример использования ImportSelector:
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class CustomImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // Подключение конфигураций в зависимости от условий
        return new String[]{ "com.example.DataSourceConfig", "com.example.ServiceConfig" };
    }
}


После этого CustomImportSelector можно использовать с @Import.
@Configuration
@Import(CustomImportSelector.class)
public class ConditionalConfig {
    // Основной класс конфигурации
}


5. Импорт конфигураций из пакетов с использованием @ComponentScan

Помимо явного импорта с помощью @Import, Spring также поддерживает автоматический поиск и регистрацию бинов, находящихся в указанных пакетах. Это достигается через аннотацию @ComponentScan, которая сканирует указанные пакеты на наличие классов, помеченных аннотациями @Component, @Service, @Repository и @Controller.

Пример использования @ComponentScan:
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example.services")
public class AppConfig {
    // Конфигурация приложения с автоматическим сканированием пакета
}


#Java #Training #Spring #Import
109 views
Java for Beginner
Что выведет код?

import java.util.Objects;

public class Task011124_1 {
    public static void main(String[] args) {
        Person0111 p1 = new Person0111("John", 25);
        Person0111 p2 = new Person0111("John", 25);
        Person0111 p3 = p1;

        System.out.println(p1.equals(p2));
        System.out.println(p1.equals(p3));
        System.out.println(p1 == p2);
        System.out.println(p1 == p3);
    }
}

class Person0111 {
    private String name;
    private int age;

    public Person0111(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person0111 person = (Person0111) o;
        return age == person.age && Objects.equals(name, person.name);
    }
}


#Tasks
122 views
Java for Beginner
Варианты ответа:
Anonymous Quiz
12%
true, true, true, true
29%
false, true, false, true
59%
true, true, false, true
0%
false, false, true, false
17 voters132 views
Java for Beginner
Я так умею, да😉😏😂

https://t.me/Java_for_beginner_dev

#Mems
122 views
Java for Beginner
Аннотация @Value в Spring

Аннотация @Value в Spring используется для внедрения значений из файлов конфигурации, таких как application.properties или application.yml, прямо в поля классов. Это позволяет легко задавать параметры среды, такие как URL базы данных, настройки сервера, и многие другие.

1. Основы аннотации @Value

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

Синтаксис аннотации @Value:
@Value("${property.key}")
private String propertyValue;
Внутри фигурных скобок ${property.key} указывается имя параметра из файла application.properties или application.yml.


2. Пример использования @Value для внедрения значений

Рассмотрим файл application.properties, содержащий следующие параметры:
server.port=8081
app.name=MyApplication
app.version=1.0.0


Теперь, с помощью аннотации @Value, можно внедрить эти параметры в класс:
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppConfig {

    @Value("${server.port}")
    private int serverPort;

    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;

    public void printConfig() {
        System.out.println("App Name: " + appName);
        System.out.println("Version: " + appVersion);
        System.out.println("Server Port: " + serverPort);
    }
}


3. Использование @Value с типами данных

Аннотация @Value поддерживает основные типы данных, такие как int, boolean, double, String и другие. Spring автоматически конвертирует значения из конфигурационного файла в нужный тип данных.

Пример:
@Value("${server.port}")
private int port;

@Value("${app.debug}")
private boolean debug;


4. Задание значений по умолчанию в @Value

С помощью @Value можно задать значения по умолчанию на случай, если параметр отсутствует в файле конфигурации. Для этого используется двоеточие после имени параметра:
@Value("${app.description:No description provided}")
private String appDescription;
Если параметр app.description отсутствует в application.properties, то будет использовано значение по умолчанию "No description provided".


5. Использование @Value для работы со списками и массивами

@Value также поддерживает внедрение списков и массивов, разделенных запятыми в файле конфигурации:
app.supported-locales=en,fr,de,ru
java
Копировать код
@Value("${app.supported-locales}")
private String[] supportedLocales;


6. Пример работы с @Value и application.yml

Также @Value работает с файлами application.yml. В данном примере покажем, как внедрить значение из структуры YAML:

Файл application.yml:
server:
  port: 8081

app:
  name: MyApp
  info:
    description: "Описание приложения"
    version: "1.0.0"


Использование значений в классе:
@Value("${app.info.description}")
private String description;

@Value("${app.info.version}")
private String version;


7. Использование @Value для внешних файлов конфигураций

Spring поддерживает загрузку свойств из внешних конфигурационных файлов с помощью аннотации @PropertySource.

Например:
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.beans.factory.annotation.Value;

@Configuration
@PropertySource("classpath:additional.properties")
public class AdditionalConfig {

    @Value("${additional.property}")
    private String additionalProperty;

    public void printProperty() {
        System.out.println("Additional Property: " + additionalProperty);
    }
}


#Java #Training #Spring #Value
112 views