Как часто работаешь с возражениями в жизни

# Исключения в Java: частота использования и best practices

Определение

Исключение (Exception) — это событие, которое нарушает нормальный ход выполнения программы. В Java исключения — это объекты, которые содержат информацию об ошибке.

Как часто работаешь с исключениями

В production коде исключения используются ежедневно и постоянно:

• Try-catch блоки — 10-50 раз в день
• Throws в методах — 20-100 раз в день
• Логирование ошибок — сотни раз
• Обработка в контроллерах — каждый endpoint

Иерархия исключений

        Throwable
           |
      ┌────┴────┐
    Error   Exception
      |        |
   (JVM)  ┌────┴────────┐
      |   Checked   Unchecked
      |   (IOException) (NullPointerException)

Типы исключений

Checked Exceptions

Обязательно обрабатывать или пробросить:

public void readFile(String filename) throws IOException {
    FileReader reader = new FileReader(filename);
}

public class FileService {
    public String readFile(String path) {
        try {
            FileReader reader = new FileReader(path);
            BufferedReader br = new BufferedReader(reader);
            return br.readLine();
        } catch (IOException e) {
            logger.error("Failed to read file: " + path, e);
            throw new RuntimeException(e);
        }
    }
}

Unchecked Exceptions

Ne обязательно обрабатывать:

public User getUserById(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException(id));
}

Custom исключения

public class UserNotFoundException extends RuntimeException {
    private Long userId;
    
    public UserNotFoundException(Long userId) {
        super("User not found: " + userId);
        this.userId = userId;
    }
    
    public Long getUserId() {
        return userId;
    }
}

Обработка исключений

Try-Catch-Finally

try {
    // код
} catch (FileNotFoundException e) {
    logger.error("File not found", e);
} catch (IOException e) {
    logger.error("IO error", e);
} finally {
    // очистка ресурсов
}

Try-with-resources

try (FileReader reader = new FileReader(filename);
     BufferedReader br = new BufferedReader(reader)) {
    String line;
    while ((line = br.readLine()) != null) {
        processLine(line);
    }
}

Обработка в Spring

GlobalExceptionHandler

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(
            UserNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ErrorResponse(
                "USER_NOT_FOUND",
                e.getMessage()
            ));
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidation(
            ValidationException e) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
            .body(new ErrorResponse(
                "VALIDATION_ERROR",
                e.getMessage()
            ));
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGeneric(
            Exception e) {
        logger.error("Unexpected error", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse(
                "INTERNAL_ERROR",
                "An unexpected error occurred"
            ));
    }
}

Best Practices

1. Специфичные исключения

catch (UserNotFoundException e) {
    return ResponseEntity.notFound().build();
}
catch (InvalidEmailException e) {
    return ResponseEntity.badRequest().build();
}

2. Логируй с контекстом

logger.error("Failed to read file: {} at line {}",
             filename, lineNumber, e);

3. Инкапсулируй низкоуровневые исключения

public User getUserFromDB(Long id) {
    try {
        // DB операция
    } catch (SQLException e) {
        logger.error("Database error", e);
        throw new UserNotFoundException("User " + id, e);
    }
}

Практический пример

@Service
public class UserService {
    
    @Transactional
    public void updateUserEmail(Long userId, String newEmail) {
        
        if (!isValidEmail(newEmail)) {
            throw new ValidationException("Invalid email format");
        }
        
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
        
        if (userRepository.existsByEmail(newEmail)) {
            throw new ValidationException("Email already exists");
        }
        
        user.setEmail(newEmail);
        userRepository.save(user);
    }
}

@RestController
public class UserController {
    
    @PutMapping("/{id}/email")
    public ResponseEntity<?> updateEmail(
            @PathVariable Long id,
            @RequestBody UpdateEmailRequest request) {
        
        try {
            userService.updateUserEmail(id, request.getEmail());
            return ResponseEntity.ok().build();
        } catch (UserNotFoundException e) {
            return ResponseEntity.notFound().build();
        } catch (ValidationException e) {
            return ResponseEntity.badRequest()
                .body(new ErrorResponse("VALIDATION_ERROR", e.getMessage()));
        }
    }
}

Вывод

Исключения в Java — это фундаментальный механизм обработки ошибок, используется ежедневно. Ключевые принципы: специфичные исключения лучше общих, логируй с контекстом, инкапсулируй низкоуровневые ошибки, используй GlobalExceptionHandler для унифицированной обработки. Правильная обработка исключений отличает production-ready код от любительского.