Кастомные исключения в Java: создание и применение на практике

public class UserNotFoundException extends Exception {
public UserNotFoundException(String message) {
super(message);
}
}

public User findUserById(long id) throws UserNotFoundException {
User user = userRepository.findById(id);
if (user == null) {
throw new UserNotFoundException("User with ID " + id + " not found");
}
return user;
}

public class InvalidOrderStatusTransitionException extends Exception {
private final String currentStatus;
private final String requestedStatus;

public InvalidOrderStatusTransitionException(String currentStatus, String requestedStatus) {
super("Cannot transition from status '" + currentStatus + 
"' to '" + requestedStatus + "'");
this.currentStatus = currentStatus;
this.requestedStatus = requestedStatus;
}

public InvalidOrderStatusTransitionException(String currentStatus, 
String requestedStatus, 
Throwable cause) {
super("Cannot transition from status '" + currentStatus + 
"' to '" + requestedStatus + "'", cause);
this.currentStatus = currentStatus;
this.requestedStatus = requestedStatus;
}

public String getCurrentStatus() {
return currentStatus;
}

public String getRequestedStatus() {
return requestedStatus;
}
}

// Проверяемое исключение
public class InsufficientFundsException extends Exception {
private final BigDecimal available;
private final BigDecimal required;

public InsufficientFundsException(BigDecimal available, BigDecimal required) {
super("Insufficient funds: available " + available + ", required " + required);
this.available = available;
this.required = required;
}

public BigDecimal getAvailable() {
return available;
}

public BigDecimal getRequired() {
return required;
}
}

// Использование
public void withdraw(BigDecimal amount) throws InsufficientFundsException {
if (balance.compareTo(amount) < 0) {
throw new InsufficientFundsException(balance, amount);
}
// Логика снятия средств
}

// Непроверяемое исключение
public class InvalidEmailFormatException extends RuntimeException {
private final String invalidEmail;

public InvalidEmailFormatException(String email) {
super("Invalid email format: " + email);
this.invalidEmail = email;
}

public String getInvalidEmail() {
return invalidEmail;
}
}

// Использование
public void register(User user) {
if (!isValidEmail(user.getEmail())) {
throw new InvalidEmailFormatException(user.getEmail());
}
// Регистрация пользователя
}

public class ResourceNotFoundException extends Exception {
private final String resourceType;
private final String resourceId;
private final String requestPath;

public ResourceNotFoundException(String resourceType, 
String resourceId, 
String requestPath) {
super(String.format("%s with ID '%s' not found at path: %s", 
resourceType, resourceId, requestPath));
this.resourceType = resourceType;
this.resourceId = resourceId;
this.requestPath = requestPath;
}

// Геттеры для всех полей
public String getResourceType() {
return resourceType;
}

public String getResourceId() {
return resourceId;
}

public String getRequestPath() {
return requestPath;
}
}

public class ServiceException extends Exception {
private final String errorCode;
private final int httpStatus;

public ServiceException(String errorCode, String message, int httpStatus) {
super(message);
this.errorCode = errorCode;
this.httpStatus = httpStatus;
}

public ServiceException(String errorCode, 
String message, 
int httpStatus, 
Throwable cause) {
super(message, cause);
this.errorCode = errorCode;
this.httpStatus = httpStatus;
}

public String getErrorCode() {
return errorCode;
}

public int getHttpStatus() {
return httpStatus;
}

// Фабричные методы для типовых ошибок
public static ServiceException notFound(String resource, String id) {
return new ServiceException(
"NOT_FOUND",
String.format("%s with ID %s not found", resource, id),
404
);
}

public static ServiceException badRequest(String details) {
return new ServiceException("BAD_REQUEST", details, 400);
}
}

public class DatabaseException extends RuntimeException {
private final String sql;
private final Map<String, Object> parameters;

// Конструкторы...

// Метод для форматированного вывода в лог
public String toLogString() {
return String.format(
"Database error: %s\nSQL: %s\nParameters: %s", 
getMessage(), sql, parameters
);
}

// Метод для проверки определенных условий
public boolean isConnectionIssue() {
return getCause() instanceof java.sql.SQLException && 
(getCause().getMessage().contains("connection") || 
getCause().getMessage().contains("timeout"));
}

// Метод для создания HTTP-ответа
public ResponseEntity<ErrorResponse> toHttpResponse() {
ErrorResponse error = new ErrorResponse(
"DATABASE_ERROR",
getMessage(),
isConnectionIssue() ? "Try again later" : "Contact support"
);
return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
}
}

// Базовый класс для всех ошибок валидации
public abstract class ValidationException extends Exception {
public ValidationException(String message) {
super(message);
}
}

// Специализированные исключения
public class EmptyFieldException extends ValidationException {
private final String fieldName;

public EmptyFieldException(String fieldName) {
super("Field '" + fieldName + "' cannot be empty");
this.fieldName = fieldName;
}

public String getFieldName() {
return fieldName;
}
}

public class InvalidFormatException extends ValidationException {
private final String fieldName;
private final String value;
private final String expectedFormat;

public InvalidFormatException(String fieldName, String value, String expectedFormat) {
super(String.format("Field '%s' with value '%s' doesn't match format: %s", 
fieldName, value, expectedFormat));
this.fieldName = fieldName;
this.value = value;
this.expectedFormat = expectedFormat;
}

// Геттеры...
}

// Использование в сервисе валидации
public class UserValidator {
public void validate(User user) throws ValidationException {
if (user.getName() == null || user.getName().trim().isEmpty()) {
throw new EmptyFieldException("name");
}

if (user.getEmail() != null && !isValidEmail(user.getEmail())) {
throw new InvalidFormatException("email", user.getEmail(), 
"username@domain.com");
}

// Другие проверки...
}

// Вспомогательные методы...
}

// Обработка в контроллере
@PostMapping("/users")
public ResponseEntity<Object> createUser(@RequestBody User user) {
try {
userValidator.validate(user);
User createdUser = userService.createUser(user);
return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
} catch (EmptyFieldException e) {
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(Map.of(
"error", "validation_error",
"field", e.getFieldName(),
"message", e.getMessage()
));
} catch (InvalidFormatException e) {
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(Map.of(
"error", "format_error",
"field", e.getFieldName(),
"value", e.getValue(),
"expectedFormat", e.getExpectedFormat(),
"message", e.getMessage()
));
} catch (ValidationException e) {
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(Map.of("error", "validation_error", "message", e.getMessage()));
}
}

public class ResourceException extends Exception {
private final String resourceType;
private final String resourceId;

public ResourceException(String message, String resourceType, String resourceId) {
super(message);
this.resourceType = resourceType;
this.resourceId = resourceId;
}

// Геттеры...
}

public class ResourceNotFoundException extends ResourceException {
public ResourceNotFoundException(String resourceType, String resourceId) {
super(
String.format("%s with ID '%s' not found", resourceType, resourceId),
resourceType,
resourceId
);
}
}

public class ResourceAccessDeniedException extends ResourceException {
private final String userId;

public ResourceAccessDeniedException(String resourceType, 
String resourceId, 
String userId) {
super(
String.format("User '%s' doesn't have access to %s with ID '%s'", 
userId, resourceType, resourceId),
resourceType,
resourceId
);
this.userId = userId;
}

public String getUserId() {
return userId;
}
}

// Использование в сервисе
public class DocumentService {
public Document getDocument(String documentId, String userId) 
throws ResourceNotFoundException, ResourceAccessDeniedException {
Document document = documentRepository.findById(documentId);

if (document == null) {
throw new ResourceNotFoundException("document", documentId);
}

if (!hasAccess(document, userId)) {
throw new ResourceAccessDeniedException("document", documentId, userId);
}

return document;
}

private boolean hasAccess(Document document, String userId) {
// Логика проверки доступа
return document.getOwnerId().equals(userId) || 
document.getSharedWith().contains(userId);
}
}

// Базовое исключение для приложения
public abstract class ApplicationException extends Exception {
private final String errorCode;

public ApplicationException(String message, String errorCode) {
super(message);
this.errorCode = errorCode;
}

public String getErrorCode() {
return errorCode;
}
}

// Подразделы исключений
public abstract class DataAccessException extends ApplicationException {
public DataAccessException(String message, String errorCode) {
super(message, errorCode);
}
}

public abstract class BusinessLogicException extends ApplicationException {
public BusinessLogicException(String message, String errorCode) {
super(message, errorCode);
}
}

// Конкретные исключения
public class EntityNotFoundException extends DataAccessException {
public EntityNotFoundException(String entity, Object id) {
super(
String.format("%s with id %s not found", entity, id),
"ENTITY_NOT_FOUND"
);
}
}

public class DuplicateEntityException extends DataAccessException {
public DuplicateEntityException(String entity, String field, Object value) {
super(
String.format("%s with %s '%s' already exists", entity, field, value),
"DUPLICATE_ENTITY"
);
}
}

// Неправильно
public class UserRepository {
public User findById(String id) {
try {
return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", 
User.class, id);
} catch (Exception e) {
log.error("Failed to find user", e); // Логирование здесь не нужно
return null; // Потеря контекста ошибки!
}
}
}

// Правильно
public class UserRepository {
public User findById(String id) throws DataAccessException {
try {
return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", 
User.class, id);
} catch (EmptyResultDataAccessException e) {
throw new EntityNotFoundException("User", id);
} catch (org.springframework.dao.DataAccessException e) {
throw new DatabaseOperationException("Failed to find user: " + id, e);
}
}
}

// Базовый класс с контекстной информацией
public abstract class ContextualException extends Exception {
private final Map<String, Object> context = new HashMap<>();

public ContextualException(String message) {
super(message);
}

public ContextualException with(String key, Object value) {
context.put(key, value);
return this;
}

public Map<String, Object> getContext() {
return Collections.unmodifiableMap(context);
}

@Override
public String getMessage() {
return super.getMessage() + " [context: " + context + "]";
}
}

// Использование
try {
// ...
} catch (IOException e) {
throw new FileProcessingException("Failed to process file")
.with("fileName", file.getName())
.with("fileSize", file.length())
.with("operation", "read");
}

@Test
public void testUserNotFoundThrowsCorrectException() {
// Given
String nonExistentId = "non-existent";
when(userRepository.findById(nonExistentId)).thenReturn(Optional.empty());

// When, Then
EntityNotFoundException exception = assertThrows(
EntityNotFoundException.class, 
() -> userService.getUserById(nonExistentId)
);

assertEquals("User with id non-existent not found", exception.getMessage());
assertEquals("ENTITY_NOT_FOUND", exception.getErrorCode());
}