// Антипаттерн: прямая передача SQLException через все слои
public User findUser(String id) throws SQLException {  // Нарушение абстракции
    return database.query("SELECT * FROM users WHERE id = ?", id);
}

// Паттерн Exception Translation: оборачивание в доменное исключение
public User findUser(String id) {
    try {
        return database.query("SELECT * FROM users WHERE id = ?", id);
    } catch (SQLException e) {
        throw new DataAccessException("Failed to load user: " + id, e);
    }
}

public void processOrder(Order order) throws OrderValidationException {
    try {
        validate(order);
    } catch (OrderValidationException e) {
        auditLog.recordValidationFailure(order.getId(), e);
        throw e;  // Тот же тип, тот же стектрейс
    }
}

public Configuration loadConfiguration() {
    try {
        return parser.parse(configFile);
    } catch (IOException e) {
        throw new ConfigurationLoadException("Cannot read config from " + configFile, e);
    }
}

// Интерфейс объявляет checked-исключение
interface DataStore {
    String read(String key) throws IOException;
}

// Реализация на основе памяти не может выбросить IOException,
// но вынуждена объявлять его или оборачивать в RuntimeException
class InMemoryStore implements DataStore {
    @Override
    public String read(String key) throws IOException {  // Нелогично
        return memoryMap.get(key);
    }
}

// Метод с checked-исключением не может быть использован как лямбда
public String fetchUrl(String url) throws IOException {
    return httpClient.get(url);
}

// Ошибка компиляции: IOException не обработано
List<String> results = urls.stream()
    .map(this::fetchUrl)  // Не компилируется
    .collect(Collectors.toList());

// Сервис не объявляет throws, использует unchecked
@Service
public class OrderService {
    public Order processOrder(OrderRequest request) {
        validate(request);  // Может выбросить ValidationException (unchecked)
        
        try {
            return orderRepository.save(request.toEntity());
        } catch (DataAccessException e) {  // Unchecked от Spring
            throw new OrderProcessingException("Failed to save order", e);
        }
    }
    
    private void validate(OrderRequest request) {
        if (request.getAmount() <= 0) {
            throw new ValidationException("Amount must be positive");
        }
    }
}

// Глобальная обработка без распространения throws через слои
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidation(ValidationException e) {
        return ResponseEntity.badRequest()
            .body(new ErrorResponse(e.getMessage()));
    }
    
    @ExceptionHandler(OrderProcessingException.class)
    public ResponseEntity<ErrorResponse> handleProcessing(OrderProcessingException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse("Order processing failed"));
    }
}

/**
 * Загружает конфигурацию приложения из файла.
 *
 * @param path путь к файлу конфигурации
 * @return загруженная конфигурация
 * @throws ConfigLoadException если файл не существует, недоступен для чтения,
 *         или содержимое не соответствует ожидаемому формату
 */
public Configuration loadConfiguration(Path path) {
    // Реализация
}

public class Task200426 {
    public static void main(String[] args) {
        try {
            method();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }

    static void method() throws Exception {
        try {
            throw new RuntimeException("Inner");
        } catch (RuntimeException e) {
            System.out.println("Inside catch");
            throw new Exception("Outer");
        }
    }
}