Exception Handling

for (int attempt = 1; attempt <= 3; attempt++) {
    try {
        externalService.call();
        break;
    } catch (TransientServiceException e) {
        if (attempt == 3) {
            throw e;
        }
        sleepBeforeRetry(attempt);
    }
}

try {
    queue.take();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    logger.info("Worker interrupted");
    return;
}

try {
    Future<?> future = executor.submit(
        () -> { throw new IllegalStateException("Task failed"); }
    );

    future.get();
} catch (ExecutionException e) {
    System.out.println(e.getCause());
}

CompletableFuture
    .supplyAsync(() -> loadQuestions())
    .exceptionally(error -> {
        logger.error("Async load failed\
}

@Transactional(
    rollbackFor = IOException.class
)
public void importQuestions() throws IOException {
    saveQuestions();
    loadAdditionalData();
}

@Transactional
public void createExam() {
    saveExam();
    throw new ExamStateException(
        "Exam cannot be activated"
    );
    // RuntimeException normally triggers rollback.
}

@Transactional
public void registerStudent(Student student) {
    saveStudent(student);
    createInitialExamAttempt(student);

    // If the transaction fails, the unit of work
    // should normally be rolled back.
}

@ExceptionHandler(Exception.class)
ResponseEntity<ApiError> handle(Exception e) {
    logger.error("Unexpected API failure\
}

@RestControllerAdvice
class ApiExceptionHandler {

    @ExceptionHandler(StudentNotFoundException.class)
    ResponseEntity<ApiError> handle(
            StudentNotFoundException e) {

        return ResponseEntity.status(404)
            .body(new ApiError("STUDENT_NOT_FOUND" 
                               e.getMessage()));
    }
}

if (exam.isSubmitted()) {
    throw new ExamAlreadySubmittedException(
        "Exam has already been submitted"
    );
}

try {
    examRepository.save(exam);
} catch (SQLException e) {
    throw new ExamPersistenceException(
        "Unable to save exam" 
        e
    );
}

try {
    return studentRepository.findById(id);
} catch (SQLException e) {
    throw new StudentPersistenceException(
        "Unable to load student " + id 
        e
    );
}

public Student getStudent(long id) {
    return repository.findById(id);
    // Let the appropriate higher layer handle the failure
}

try {
    paymentService.charge(order);
} catch (PaymentException e) {
    logger.warn("Payment failed" e);
    showPaymentFailure();
}

for (Question question : questions) {
    try {
        importQuestion(question);
    } catch (InvalidQuestionException e) {
        logger.warn(
            "Skipping invalid question {}\
}}

try {
    uploadDocument(document);
} catch (IOException e) {
    throw new DocumentProcessingException(
        "Failed to upload document " + document.getId()
}

try {
    authenticate(username, password);
} catch (AuthenticationException e) {
    logger.warn(
        "Authentication failed for user {}\
}

throw new StudentPersistenceException(
    "Unable to save student with id " + studentId
);

try {
    return jdbcTemplate.queryForObject(
        sql,
        studentRowMapper,
        id
    );
} catch (DataAccessException e) {
    throw new StudentPersistenceException(
        "Database lookup failed\
}

public Student findStudent(long id) {
    try {
        return repository.findById(id);
    } catch (SQLException e) {
        throw new StudentPersistenceException(
            "Unable to load student " + id e
        );
    }
}

@RestControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    ResponseEntity<String> handle(IllegalArgumentException e) {
        return ResponseEntity.badRequest()
            .body(e.getMessage());
    }
}

@RestControllerAdvice
class ApiExceptionHandler {

    @ExceptionHandler(StudentNotFoundException.class)
    ResponseEntity<String> handle(
            StudentNotFoundException e) {

        return ResponseEntity
            .status(404)
            .body(e.getMessage());
    }
}

try {
    repository.save(order);
} catch (SQLException e) {
    throw new OrderPersistenceException(
        "Unable to persist order\
}

try {
    processOrder();
} catch (OrderException e) {
    logger.error("Order processing failed\
}

static void controller() {
    service();
}

static void service() {
    repository();
}

static void repository() {
    throw new RuntimeException("Database failure");
}

try {
    loadQuestions();
} catch (IOException e) {
    e.printStackTrace();
}

SQLException databaseError =
    new SQLException("Connection refused");

RuntimeException serviceError =
    new RuntimeException("Unable to load students\

IOException cause = new IOException("File unavailable");

RuntimeException failure =
    new RuntimeException("Exam loading failed");

failure.initCause(cause);

System.out.println(failure.getCause());

try {
    repository.save(student);
} catch (SQLException e) {
    throw new StudentPersistenceException("Save failed\
}

try {
    executeBusinessOperation();
} catch (Exception e) {
    logger.error("Business operation failed\
}

try {
    Integer.parseInt(input);
} catch (NumberFormatException e) {
    System.out.println("Invalid number");
}