public class IntegerCache {
    
    public static void main(String[] args) {
        //В пределах кэша (-128..127)
        Integer a1 = 100;
        Integer b1 = 100;
        System.out.println("100 == 100: " + (a1 == b1));     // true (один объект)
        System.out.println("100 equals 100: " + a1.equals(b1)); // true
        
        //Вне кэша
        Integer a2 = 200;
        Integer b2 = 200;
        System.out.println("200 == 200: " + (a2 == b2));     // false (разные объекты!)
        System.out.println("200 equals 200: " + a2.equals(b2)); // true
        
        //Разные способы создания
        Integer a3 = Integer.valueOf(127); // из кэша
        Integer b3 = new Integer(127);     // новый объект (deprecated)
        System.out.println("valueOf(127) == new Integer(127): " + (a3 == b3)); // false
        
        //Опасность в коллекциях
        var map = new java.util.HashMap<Integer, String>();
        map.put(200, "value");
        System.out.println("map.get(200): " + map.get(200)); // работает, т.к. внутри equals
        
        //Правильное сравнение
        Integer x = 300;
        Integer y = 300;
        if (x.equals(y)) {
            System.out.println("300 equals 300 — корректно");
        }
        
        //null-safe сравнение
        Integer nullable = null;
        System.out.println("Objects.equals: " + Objects.equals(nullable, 300));
    }
}

public class Task250526 {
    public static void main(String[] args) {
        Short a = 100;
        Short b = 100;
        Short c = 200;
        Short d = 200;
        
        System.out.println(a == b);
        System.out.println(c == d);
        System.out.println(c.equals(d));
    }
}

2024-01-15 10:23:14 [http-nio-8080-exec-3] INFO  OrderService - Processing order
2024-01-15 10:23:14 [http-nio-8080-exec-1] INFO  PaymentService - Charging card
2024-01-15 10:23:14 [http-nio-8080-exec-3] WARN  InventoryService - Low stock
2024-01-15 10:23:15 [http-nio-8080-exec-2] ERROR OrderService - Payment failed

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

public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public void processOrder(String orderId, String userId) {
        // Установка контекста в начале операции
        MDC.put("orderId", orderId);
        MDC.put("userId", userId);
        MDC.put("operation", "processOrder");
        
        try {
            logger.info("Starting order processing");
            validateOrder(orderId);
            chargePayment(orderId, userId);
            updateInventory(orderId);
            logger.info("Order processing completed");
        } catch (Exception e) {
            logger.error("Order processing failed", e);
            throw e;
        } finally {
            // Обязательная очистка контекста
            MDC.clear();
        }
    }
}

<property name="LOG_PATTERN" 
          value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{userId}] [%X{orderId}] - %msg%n"/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>${LOG_PATTERN}</pattern>
    </encoder>
</appender>

2024-01-15 10:23:14.123 [http-nio-8080-exec-3] INFO  OrderService [user-42] [order-789] - Starting order processing
2024-01-15 10:23:14.145 [http-nio-8080-exec-3] INFO  PaymentService [user-42] [order-789] - Charging payment
2024-01-15 10:23:14.167 [http-nio-8080-exec-3] INFO  OrderService [user-42] [order-789] - Order processing completed

import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;

@Component
public class LoggingContextFilter extends OncePerRequestFilter {
    
    private static final String REQUEST_ID_HEADER = "X-Request-Id";
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        // Генерация или извлечение идентификатора запроса
        String requestId = request.getHeader(REQUEST_ID_HEADER);
        if (requestId == null || requestId.isBlank()) {
            requestId = UUID.randomUUID().toString();
        }
        
        // Извлечение контекста аутентификации
        String userId = extractUserId(request);
        String sessionId = request.getSession(false) != null ? 
            request.getSession().getId() : "anonymous";
        
        // Установка MDC
        MDC.put("requestId", requestId);
        MDC.put("userId", userId != null ? userId : "anonymous");
        MDC.put("sessionId", sessionId);
        MDC.put("method", request.getMethod());
        MDC.put("uri", request.getRequestURI());
        
        // Проброс requestId в ответ для клиентской трассировки
        response.setHeader(REQUEST_ID_HEADER, requestId);
        
        try {
            filterChain.doFilter(request, response);
        } finally {
            // Очистка обязательна, иначе поток из пула вернется с загрязненным контекстом
            MDC.clear();
        }
    }
    
    private String extractUserId(HttpServletRequest request) {
        // Извлечение из SecurityContext или токена
        return SecurityContextHolder.getContext().getAuthentication() != null ?
            SecurityContextHolder.getContext().getAuthentication().getName() : null;
    }
}

<property name="LOG_PATTERN" 
          value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{requestId}] [%X{userId}] [%X{method} %X{uri}] - %msg%n"/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>${LOG_PATTERN}</pattern>
    </encoder>
</appender>

@Service
public class OrderClient {
    private final RestTemplate restTemplate;
    
    public OrderDto getOrder(String orderId) {
        String requestId = MDC.get("requestId");
        
        HttpHeaders headers = new HttpHeaders();
        headers.set("X-Request-Id", requestId);  // Propagation
        
        HttpEntity<Void> entity = new HttpEntity<>(headers);
        ResponseEntity<OrderDto> response = restTemplate.exchange(
            "http://order-service/orders/" + orderId,
            HttpMethod.GET,
            entity,
            OrderDto.class
        );
        
        return response.getBody();
    }
}

// Антипаттерн: MDC теряется при асинхронном выполнении
CompletableFuture.runAsync(() -> {
    // MDC пуст — задача выполняется в другом потоке
    logger.info("Async task");  // Нет requestId, userId
});

Map<String, String> contextMap = MDC.getCopyOfContextMap();

CompletableFuture.runAsync(() -> {
    MDC.setContextMap(contextMap);  // Восстановление контекста
    try {
        logger.info("Async task with context");
        processAsync();
    } finally {
        MDC.clear();
    }
});

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setTaskDecorator(new MdcTaskDecorator());
        executor.initialize();
        return executor;
    }
}

public class MdcTaskDecorator implements TaskDecorator {
    @Override
    public Runnable decorate(Runnable runnable) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                MDC.setContextMap(contextMap);
                runnable.run();
            } finally {
                MDC.clear();
            }
        };
    }
}

<encoder class="net.logstash.logback.encoder.LogstashEncoder"/>

{
  "@timestamp": "2024-01-15T10:23:14.123+00:00",
  "message": "Order processing completed",
  "logger_name": "com.example.OrderService",
  "level": "INFO",
  "thread_name": "http-nio-8080-exec-3",
  "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "userId": "user-42",
  "sessionId": "session-xyz",
  "method": "POST",
  "uri": "/api/orders"
}

import com.fasterxml.jackson.databind.ObjectMapper;

public class Task260526 {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        String json = "{\"name\":\"Buddy\",\"breed\":\"Labrador\"}";

        Animal260526 animal = mapper.readValue(json, Animal260526.class);
        System.out.println(animal.getClass().getSimpleName());
    }
}

interface Animal260526 {
    String getName();
}

class Dog260526 implements Animal260526 {
    public String name;
    public String breed;

    public Dog260526() {}

    @Override
    public String getName() { return name; }
}

public class ComparatorComparing {
    
    static class Person {
        String name;
        int age;
        LocalDate birthDate;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + "(" + age + ")";
        }
    }
    
    // Класс без Comparable
    static class ExternalId {
        String prefix;
        int number;
        
        ExternalId(String prefix, int number) {
            this.prefix = prefix;
            this.number = number;
        }
        
        @Override
        public String toString() {
            return prefix + "-" + number;
        }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );
        
        //Работает: String реализует Comparable
        people.sort(Comparator.comparing(p -> p.name));
        System.out.println("Sorted by name: " + people);
        
        //Работает: int примитив через comparingInt
        people.sort(Comparator.comparingInt(p -> p.age));
        System.out.println("Sorted by age: " + people);
        
        //Ошибка: ExternalId не реализует Comparable
        List<ExternalId> ids = Arrays.asList(
            new ExternalId("A", 10),
            new ExternalId("B", 5),
            new ExternalId("A", 20)
        );
        
        // ids.sort(Comparator.comparing(id -> id)); // не скомпилируется!
        
        //Решение 1: явный компаратор для ключа
        ids.sort(Comparator.comparing(
            (ExternalId id) -> id.prefix,
            Comparator.naturalOrder() // для строк
        ));
        System.out.println("Sorted by prefix: " + ids);
        
        //Решение 2: составной компаратор через thenComparing
        ids.sort(Comparator
            .comparing((ExternalId id) -> id.prefix)
            .thenComparingInt(id -> id.number));
        System.out.println("Sorted by prefix then number: " + ids);
        
        //Решение 3: собственный компаратор для ключа
        Comparator<ExternalId> byNumberDesc = Comparator.comparing(
            (ExternalId id) -> id.number,
            (n1, n2) -> n2 - n1 // обратный порядок
        );
        ids.sort(byNumberDesc);
        System.out.println("Sorted by number desc: " + ids);
    }
}

import java.util.*;

public class Task270526 {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 25),
            new Person("Bob", 30),
            new Person("Charlie", 20)
        );
        
        Comparator<Person> comparator = Comparator.comparing(p -> p.age);
        people.sort(comparator);
        System.out.println(people);
    }
    
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + ":" + age;
        }
    }
}

<<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.14</version>
</dependency>
<<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.9</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<<configuration>

    <!-- Переменная для профиля -->
    <springProperty scope="context" name="PROFILE" source="spring.profiles.active" defaultValue="default"/>
    <!-- Для не-Spring проекта используйте системное свойство -->
    <property name="PROFILE" value="${PROFILE:-default}"/>

    <!-- Консоль: INFO и выше -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>

    <!-- Файл ошибок: ERROR и выше -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/errors.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/errors.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n%ex</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
    </appender>

    <!-- Файл отладки: DEBUG и выше, только при профиле dev -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/debug.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/debug.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{operation}] - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Корневой логгер -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ERROR_FILE"/>
    </root>

    <!-- Логгер приложения -->
    <logger name="library" level="INFO">
        <!-- DEBUG-файл подключается условно -->
    </logger>

    <!-- Условное включение DEBUG-файла через профиль -->
    <if condition='property("PROFILE").contains("dev")'>
        <then>
            <root level="DEBUG">
                <appender-ref ref="CONSOLE"/>
                <appender-ref ref="ERROR_FILE"/>
                <appender-ref ref="DEBUG_FILE"/>
            </root>
            <logger name="library" level="DEBUG"/>
        </then>
    </if>

</configuration>

<<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.11</version>
</dependency>