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

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

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
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
Что выведет код?

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
Варианты ответа:
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
Ну что тут скажешь...🤷‍♂️🤪😂😂😂

https://t.me/Java_for_beginner_dev

#Mems
Валидация и валидационные аннотации в 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
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
Что выведет код?

Задача по 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
Подробный разбор решения задачи 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
@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
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
Что выведет код?

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
Я так умею, да😉😏😂

https://t.me/Java_for_beginner_dev

#Mems
Аннотация @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
Что выведет код?

Задача по Spring. Аннотации @Import и @Value Сложность легкая.

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

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

public class Main011124_2 {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig0111.class);
Client0111 client = context.getBean(Client0111.class);
client.printMessage();
}
}

@Configuration
@Import(ServiceConfig0111.class)
class MainConfig0111 {
@Bean
public Client0111 client0111(Service0111 service) {
return new Client0111(service);
}
}

@Configuration
class ServiceConfig0111 {
@Bean
public Service0111 service0111(@Value("${message:Hello, Spring}") String message) {
return new Service0111(message);
}
}

class Client0111 {
private final Service0111 service;

public Client0111(Service0111 service) {
this.service = service;
}

public void printMessage() {
System.out.println(service.message());
}
}

record Service0111(String message) {
}


#TasksSpring
Подробный разбор решения задачи Task011124_2

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

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

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

Аннотация @Import:
Аннотация
@Import(ServiceConfig0111.class) в классе MainConfig0111 используется для импорта конфигурации из другого класса, ServiceConfig0111. Это позволяет разделять конфигурацию приложения на несколько файлов и управлять зависимостями между ними.

Аннотация @Value:
Аннотация @Value("${message:Hello, Spring}") в методе service0111() устанавливает значение для параметра message. Здесь используется шаблон с подстановкой значения по умолчанию: если в настройках Spring нет переменной message, будет использовано значение "Hello, Spring".

Метод registerUser():
В классе Client0111 метод printMessage() вызывает метод getMessage() объекта Service0111, который возвращает сообщение, переданное в конструктор этого объекта.

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

Программа создает контекст Spring с помощью AnnotationConfigApplicationContext, который сканирует конфигурационный класс MainConfig0111. Этот класс импортирует конфигурацию из ServiceConfig0111, где находится бин Service0111.
В методе service0111() используется аннотация
@Value, чтобы задать значение для параметра message. Поскольку переменная message не была определена в контексте (например, в файле свойств), используется значение по умолчанию "Hello, Spring".
Контекст создает бин Client0111, который получает бин Service0111 через конструкторную инъекцию.
Вызывается метод printMessage(), который выводит значение message из бина Service0111.


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

Аннотация @Import: Позволяет разделять конфигурацию Spring на несколько классов. Это улучшает модульность приложения и помогает управлять конфигурацией большого количества бинов.

Аннотация
@Value: Позволяет извлекать значения из внешних конфигураций, а также устанавливать значения по умолчанию, если переменные не заданы. В этом примере используется значение по умолчанию "Hello, Spring", так как переменная message не была передана.

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

#Solution_TasksSpring
Всем доброго субботне-рабочего утра!😉

Так как на сегодня постов не предвидится, предлагаю всем перейти в наш чат (https://t.me/Java_Beginner_chat) и просто поболтать).

Я вот нашел где генерить неплохие картинки)


А как Вы проводите "выходной"?😂
Всем уютного воскресного утра!🖐

Сегодня официальный выходной поэтому можно немного полениться😜

Но изучение Java нельзя останавливать! Ни в коем случае🤪😂

Поэтому как и всегда в 16:00 мы встречаемся в Яндекс.Телемост и посмотрим лайф-кодинг
@MrAbhorrent!💪

Ждем всех!🫵