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; }
}