<dependencies>
    <!-- Фасадный API, обязателен для компиляции -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>2.0.9</version>
    </dependency>
    
    <!-- Реализация Logback с нативным SLF4J binding -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.4.11</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

dependencies {
    implementation 'org.slf4j:slf4j-api:2.0.9'
    runtimeOnly 'ch.qos.logback:logback-classic:1.4.11'
}

dependencies {
    implementation("org.slf4j:slf4j-api:2.0.9")
    runtimeOnly("ch.qos.logback:logback-classic:1.4.11")
}

SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:.../logback-classic-1.4.11.jar]
SLF4J: Found binding in [jar:file:.../slf4j-simple-2.0.9.jar]
SLF4J: See https://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [ch.qos.logback.classic.util.ContextSelectorStaticBinder]

<!-- Maven: исключение конфликтующего binding -->
<dependency>
    <groupId>com.some.library</groupId>
    <artifactId>library-with-log4j</artifactId>
    <version>1.0</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

// Gradle: исключение конфликтующего binding
implementation('com.some.library:library-with-log4j:1.0') {
    exclude group: 'org.slf4j', module: 'slf4j-log4j12'
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PaymentService {
    // Конвенция: private static final, имя logger или LOG
    private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
    
    public void processPayment(String paymentId) {
        logger.debug("Starting payment processing for id={}", paymentId);
        
        try {
            executePayment(paymentId);
            logger.info("Payment {} processed successfully", paymentId);
        } catch (PaymentException e) {
            logger.error("Payment {} failed: {}", paymentId, e.getMessage(), e);
        }
    }
}

org.springframework.boot:spring-boot-starter-logging
    ch.qos.logback:logback-classic
    org.apache.logging.log4j:log4j-to-slf4j
    org.slf4j:jul-to-slf4j

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<dependencies>
    <!-- Транзитивно включает logback-classic и slf4j-api -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Явное подключение не требуется, но допустимо для управления версией -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
    </dependency>
</dependencies>

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.4'
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // Никаких дополнительных зависимостей для логирования
}

# Maven
mvn dependency:tree | grep -E "(slf4j|logback|log4j)"

# Gradle
gradle dependencies --configuration runtimeClasspath | grep -E "(slf4j|logback|log4j)"

+--- org.springframework.boot:spring-boot-starter-logging -> 3.2.0
|    +--- ch.qos.logback:logback-classic:1.4.11
|    |    +--- ch.qos.logback:logback-core:1.4.11
|    |    \--- org.slf4j:slf4j-api:2.0.9
|    +--- org.apache.logging.log4j:log4j-to-slf4j:2.21.1
|    \--- org.slf4j:jul-to-slf4j:2.0.9

<!-- Maven: переход на Log4j2 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j2</artifactId>
    </dependency>
</dependencies>

// Gradle: переход на Log4j2
dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web') {
        exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
    }
    implementation 'org.springframework.boot:spring-boot-starter-log4j2'
}

# Корневой уровень
logging.level.root=INFO

# Уровень для пакета
logging.level.com.example.service=DEBUG

# Уровень для конкретного класса
logging.level.com.example.service.PaymentService=TRACE

# Формат вывода
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

# Файл логов
logging.file.name=application.log
logging.file.path=/var/log/myapp

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <springProfile name="dev">
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
        <root level="DEBUG">
            <appender-ref ref="CONSOLE"/>
        </root>
    </springProfile>
    
    <springProfile name="prod">
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>/var/log/app/application.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>/var/log/app/application.%d{yyyy-MM-dd}.log</fileNamePattern>
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
        <root level="INFO">
            <appender-ref ref="FILE"/>
        </root>
    </springProfile>
</configuration>

import java.time.*;
import java.time.temporal.ChronoUnit;

public class ZonedDateTimeTricky {
    public static void main(String[] args) {
        ZonedDateTime utc = ZonedDateTime.of(2025, 1, 1, 12, 0, 0, 0, ZoneId.of("UTC"));
        ZonedDateTime paris = ZonedDateTime.of(2025, 1, 1, 13, 0, 0, 0, ZoneId.of("Europe/Paris"));
        System.out.print(utc.equals(paris));
        System.out.print(" " + utc.isEqual(paris));
    }
}

public class FileDeleteExample {
    
    //Антипаттерн: игнорирование возвращаемого значения
    public static void badDelete(String path) {
        File file = new File(path);
        file.delete(); // Возврат значения проигнорирован - ошибка не будет замечена
        System.out.println("Файл " + path + " удален (предположительно)");
        // Если файл не удалился, программа об этом не знает
    }
    
    //Недостаточно: проверка без обработки
    public static void insufficientCheck(String path) {
        File file = new File(path);
        if (!file.delete()) {
            System.out.println("Не удалось удалить файл"); // Нет информации о причине
        }
    }
    
    //Решение 1: Files.delete() с исключениями (рекомендуется)
    public static void goodDeleteNio(String path) {
        try {
            Files.delete(Path.of(path));
            System.out.println("Файл успешно удален: " + path);
        } catch (NoSuchFileException e) {
            System.err.println("Файл не существует: " + path);
        } catch (DirectoryNotEmptyException e) {
            System.err.println("Каталог не пуст: " + path);
        } catch (AccessDeniedException e) {
            System.err.println("Нет прав на удаление: " + path);
        } catch (IOException e) {
            System.err.println("Ошибка удаления: " + e.getMessage());
        }
    }
    
    //Решение 2: deleteIfExists() - не выбрасывает исключение при отсутствии файла
    public static void goodDeleteIfExists(String path) throws IOException {
        boolean deleted = Files.deleteIfExists(Path.of(path));
        if (deleted) {
            System.out.println("Файл удален");
        } else {
            System.out.println("Файл не существовал");
        }
        // Другие ошибки (доступ, занятость) все равно выбросят IOException
    }
    
    //Решение 3: проверка возвращаемого значения с собственным исключением
    public static void checkedFileDelete(String path) throws IOException {
        File file = new File(path);
        if (!file.delete()) {
            throw new IOException("Не удалось удалить файл: " + path + 
                " (файл существует? " + file.exists() +
                ", можно записать? " + file.canWrite() + ")");
        }
    }
}

import java.io.File;
import java.io.IOException;

public class Task130526 {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");
        file.createNewFile();
        
        File dir = new File("testDir");
        dir.mkdir();
        
        System.out.print(file.delete() + " ");
        System.out.print(file.delete() + " ");
        System.out.print(dir.delete() + " ");
        
        dir.mkdir();
        File fileInDir = new File(dir, "test.txt");
        fileInDir.createNewFile();
        
        System.out.print(dir.delete());
    }
}

public void quickSort(int[] array, int left, int right) {
    logger.trace("Entering quickSort(left={}, right={})", left, right);
    
    if (left < right) {
        int pivot = partition(array, left, right);
        logger.trace("Pivot index={}, array state={}", pivot, Arrays.toString(array));
        
        quickSort(array, left, pivot - 1);
        quickSort(array, pivot + 1, right);
    }
    
    logger.trace("Exiting quickSort(left={}, right={})", left, right);
}

public User authenticate(String username, String passwordHash) {
    logger.debug("Authentication attempt for user={}", username);
    
    User user = userRepository.findByUsername(username);
    logger.debug("User lookup result: found={}, status={}", 
        user != null, user != null ? user.getStatus() : "N/A");
    
    if (user == null || !user.getPasswordHash().equals(passwordHash)) {
        logger.debug("Authentication failed for user={}: invalid credentials", username);
        return null;
    }
    
    if (user.getStatus() == UserStatus.LOCKED) {
        logger.debug("Authentication failed for user={}: account locked", username);
        return null;
    }
    
    logger.debug("Authentication successful for user={}, roles={}", 
        username, user.getRoles());
    return user;
}

@Service
public class OrderProcessingService {
    
    @EventListener
    public void onApplicationReady(ApplicationReadyEvent event) {
        logger.info("Order processing service started, version={}, profile={}",
            buildProperties.getVersion(), 
            Arrays.toString(environment.getActiveProfiles()));
    }
    
    public Order processOrder(OrderRequest request) {
        logger.info("Processing orderId={}, customerId={}, amount={}", 
            request.getOrderId(), request.getCustomerId(), request.getAmount());
        
        Order order = executeBusinessLogic(request);
        
        logger.info("Order {} processed successfully, status={}, durationMs={}", 
            order.getId(), order.getStatus(), order.getProcessingDuration());
        return order;
    }
}

public void sendNotification(User user, Notification notification) {
    try {
        notificationGateway.send(user.getEmail(), notification);
        logger.info("Notification sent to user={}", user.getId());
    } catch (GatewayTimeoutException e) {
        logger.warn("Notification gateway timeout for user={}, will retry asynchronously", 
            user.getId());
        enqueueForRetry(user, notification);
    }
}

public void chargePayment(Payment payment) {
    try {
        paymentGateway.charge(payment);
        logger.info("Payment {} charged successfully", payment.getId());
    } catch (PaymentGatewayException e) {
        if (e.isRetryable()) {
            logger.warn("Payment {} failed with retryable error, scheduling retry", 
                payment.getId());
            scheduleRetry(payment);
        } else {
            logger.error("Payment {} failed with non-retryable error: {}", 
                payment.getId(), e.getMessage(), e);
            markAsFailed(payment);
        }
    }
}

// Псевдокод конфигурации Logback
Logger root = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
root.setLevel(Level.INFO);

Logger servicePackage = LoggerFactory.getLogger("com.example.service");
servicePackage.setLevel(Level.DEBUG);

Logger orderService = LoggerFactory.getLogger("com.example.service.OrderService");
// orderService не имеет явного уровня, наследует DEBUG от com.example.service

<!-- Logback: отключение additivity для изоляции вывода -->
<logger name="com.example.audit" level="INFO" additivity="false">
    <appender-ref ref="AUDIT_FILE"/>
</logger>

// Правильно: ленивое вычисление через параметризацию
logger.debug("Processing batch of {} items, estimated memory={}MB", 
    batchSize, estimatedMemory);

// Избыточно: guard-метод не нужен для простых параметров
if (logger.isDebugEnabled()) {
    logger.debug("Simple message");
}

// Оправдано: guard для дорогостоящих операций
if (logger.isDebugEnabled()) {
    logger.debug("Complex state: {}", serializeFullObjectGraph(state));
}

import java.util.*;

public class Task140526 {
    public static void main(String[] args) {
        List<Integer> list = List.of(1, 2, 3, 4, 5);
        Collections.shuffle(list);
        System.out.println(list);
    }
}