// Кастомное unchecked-исключение для домена
public class UserNotFoundException extends RuntimeException {
    private final String userId;
    
    public UserNotFoundException(String userId) {
        super("User not found: " + userId);
        this.userId = userId;
    }
}

// Репозиторий скрывает детали SQL, транслирует в доменное исключение
public User findById(String id) {
    try {
        Connection conn = dataSource.getConnection();
        // ... выполнение запроса
    } catch (SQLException e) {
        throw new DataAccessException("Database error while loading user", e);
    }
}

// Сервисный слой чист, без throws
public User getUser(String id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException(id));
}

// Контроллер также чист, фокусируется на HTTP-логике
public UserDto getUserEndpoint(String id) {
    User user = userService.getUser(id);
    return userMapper.toDto(user);
}

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // Метод объявлен без throws, но может выбросить unchecked исключения
    Optional<Order> findByOrderNumber(String orderNumber);
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public Order processOrder(String orderNumber) {
        // Никаких try-catch для checked-исключений
        Order order = orderRepository.findByOrderNumber(orderNumber)
            .orElseThrow(() -> new OrderNotFoundException(orderNumber));
        
        // При ошибке базы данных будет выброшено DataAccessException
        // Транзакция откатится автоматически
        return executeBusinessLogic(order);
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(DataAccessException.class)
    public ResponseEntity<ErrorResponse> handleDatabaseError(DataAccessException e) {
        // Логирование, метрики, уведомление
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body(new ErrorResponse("Database temporarily unavailable"));
    }
    
    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(OrderNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ErrorResponse(e.getMessage()));
    }
}

fun updateOrderQuantity(orderId: OrderId, quantity: Int) {
    require(quantity > 0) { "Quantity must be positive" }
    val order = loadOrder(orderId)  // Может выбросить исключение, но не требует try-catch
    order.quantity = quantity
    storeOrder(order)  // То же самое
}

// Метод с checked-исключением
public String fetchDataFromUrl(String url) throws IOException {
    return httpClient.fetch(url);
}

// Невозможно напрямую использовать в Stream
List<String> urls = List.of("http://api1.com", "http://api2.com");
List<String> data = urls.stream()
    .map(this::fetchDataFromUrl)  // Ошибка компиляции: IOException не обработано
    .collect(Collectors.toList());

List<String> data = urls.stream()
    .map(url -> {
        try {
            return fetchDataFromUrl(url);
        } catch (IOException e) {
            throw new RuntimeException(e);  // Уничтожение семантики checked-исключения
        }
    })
    .collect(Collectors.toList());

// Checked-исключение для редкого, но критичного сценария восстановления
public class PaymentReversalRequiredException extends Exception {
    private final Payment originalPayment;
    private final String reasonCode;
    
    public PaymentReversalRequiredException(Payment payment, String reasonCode, String message) {
        super(message);
        this.originalPayment = payment;
        this.reasonCode = reasonCode;
    }
    
    // Методы доступа для логики восстановления
    public Payment getOriginalPayment() { return originalPayment; }
    public String getReasonCode() { return reasonCode; }
}

// Unchecked-исключения для всех остальных сценариев
public class PaymentProcessingException extends RuntimeException {
    private final String transactionId;
    
    public PaymentProcessingException(String transactionId, String message, Throwable cause) {
        super(message, cause);
        this.transactionId = transactionId;
    }
}

public class InvalidPaymentRequestException extends IllegalArgumentException {
    private final String fieldName;
    
    public InvalidPaymentRequestException(String fieldName, Object value) {
        super(String.format("Invalid value for field %s: %s", fieldName, value));
        this.fieldName = fieldName;
    }
}

import io.vavr.control.Either;
import io.vavr.control.Try;

public Either<PaymentError, PaymentReceipt> processPayment(PaymentRequest request) {
    return validateRequest(request)
        .flatMap(this::authorizePayment)
        .flatMap(this::executeTransfer)
        .map(this::generateReceipt);
}

private Either<PaymentError, ValidatedRequest> validateRequest(PaymentRequest request) {
    if (request.getAmount() <= 0) {
        return Either.left(new PaymentError("INVALID_AMOUNT", "Amount must be positive"));
    }
    if (request.getCurrency() == null) {
        return Either.left(new PaymentError("MISSING_CURRENCY", "Currency is required"));
    }
    return Either.right(new ValidatedRequest(request));
}

import java.io.IOException;

public class Task100426 {
    public static void main(String[] args) {
        try {
            method();
        } catch (Exception e) {
            System.out.println("Catch: " + e.getClass().getSimpleName());
        }
    }

    static void method() {
        try {
            throw new IOException("IO");
        } catch (IOException e) {
            throw new RuntimeException("Runtime");
        } finally {
            return;
        }
    }
}

public class ThreadLocalLeak {
    
    //Антипаттерн: ThreadLocal без очистки
    private static final ThreadLocal<UserContext> CURRENT_USER = new ThreadLocal<>();
    
    public static void processRequestBad(User user) {
        CURRENT_USER.set(new UserContext(user)); // Установили
        // ... обработка запроса
        // Забыли remove() — данные останутся в потоке навсегда
    }
    
    //Решение: try-finally с remove()
    public static void processRequestGood(User user) {
        try {
            CURRENT_USER.set(new UserContext(user));
            // ... обработка запроса
        } finally {
            CURRENT_USER.remove(); // Гарантированная очистка
        }
    }
    
    // Демонстрация утечки
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // Плохой вариант
        for (int i = 0; i < 10; i++) {
            final int requestId = i;
            executor.submit(() -> {
                processRequestBad(new User("User" + requestId));
            });
        }
        
        Thread.sleep(1000);
        
        // Теперь в потоках пула остались старые данные
        executor.submit(() -> {
            UserContext context = CURRENT_USER.get(); // Может вернуть данные от старого запроса!
            System.out.println("Остались данные: " + context);
        });
        
        executor.shutdown();
    }
    
    // Для веб-фильтра (Spring-стиль)
    public static class WebFilter {
        public void doFilter(Request request, FilterChain chain) {
            try {
                // Установка контекста из запроса
                UserContext.setCurrent(request.getUser());
                chain.proceed();
            } finally {
                UserContext.clear(); // Обязательная очистка после каждого запроса
            }
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Task130426 {
    static class UserContext130426 {
        String userId;
        UserContext130426(String userId) { this.userId = userId; }
    }

    static ThreadLocal<UserContext130426> currentUser = new ThreadLocal<>();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        executor.submit(() -> {
            currentUser.set(new UserContext130426("user1"));
            System.out.print(currentUser.get().userId + " ");
        });
        
        executor.submit(() -> {
            UserContext130426 ctx = currentUser.get();
            System.out.println(ctx == null ? "null" : ctx.userId);
        });

        executor.shutdown();
    }
}

public void simpleTryFinally() {
    try {
        processData();
    } finally {
        cleanup();
    }
}

public String readFile(String path) throws IOException {
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader(path));
        return reader.readLine();
    } finally {
        if (reader != null) {
            reader.close();
        }
    }
}

public void copyFile(String sourcePath, String destPath) throws IOException {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream(sourcePath);
        try {
            fos = new FileOutputStream(destPath);
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } finally {
            if (fos != null) {
                fos.close();
            }
        }
    } finally {
        if (fis != null) {
            fis.close();
        }
    }
}