Аналог NotImplementedException в Java из .NET: как использовать

import java.util.Collections;
import java.util.List;

public class ImmutableExample {
 private final List<String> items;
 
 public ImmutableExample(List<String> items) {
 this.items = Collections.unmodifiableList(items);
 }
 
 public void addItem(String item) {
 // Этот метод не должен работать - список неизменяемый
 throw new UnsupportedOperationException("Cannot add items to immutable list");
 }
}

public interface DataProcessor {
 void process(Data data);
 void validate(Data data); // Может не поддерживаться всеми реализациями
}

public class SimpleDataProcessor implements DataProcessor {
 @Override
 public void process(Data data) {
 // Реализация обработки
 }
 
 @Override
 public void validate(Data data) {
 throw new UnsupportedOperationException("Validation not supported in this processor");
 }
}

<dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.2+</version>
</dependency>

implementation 'org.apache.commons:commons-lang3:3.2+'

import org.apache.commons.lang3.NotImplementedException;

public class Feature {
 public void doSomething() {
 // TODO: Реализовать метод
 throw new NotImplementedException("Method doSomething() is not implemented yet");
 }
 
 public void doSomethingElse() {
 try {
 // Какая-то операция, которая может выбросить исключение
 } catch (Exception ex) {
 throw new NotImplementedException("Error in doSomethingElse()", ex);
 }
 }
}

public class NotImplementedException extends UnsupportedOperationException {
 public NotImplementedException() {
 super("Method not implemented");
 }
 
 public NotImplementedException(String message) {
 super(message);
 }
 
 public NotImplementedException(String message, Throwable cause) {
 super(message, cause);
 }
 
 public NotImplementedException(Throwable cause) {
 super(cause);
 }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class NotImplementedException extends UnsupportedOperationException {
 private static final Map<String, NotImplementedException> CACHE = new ConcurrentHashMap<>();
 
 private final String methodName;
 private final String className;
 
 public NotImplementedException(String className, String methodName) {
 super(String.format("Method %s.%s() is not implemented", className, methodName));
 this.className = className;
 this.methodName = methodName;
 }
 
 public NotImplementedException(String className, String methodName, Throwable cause) {
 super(String.format("Method %s.%s() is not implemented", className, methodName), cause);
 this.className = className;
 this.methodName = methodName;
 }
 
 // Кеширование исключений для производительности
 public static NotImplementedException forMethod(String className, String methodName) {
 String key = className + "#" + methodName;
 return CACHE.computeIfAbsent(key, k -> new NotImplementedException(className, methodName));
 }
 
 // Геттеры для дополнительной информации
 public String getMethodName() {
 return methodName;
 }
 
 public String getClassName() {
 return className;
 }
}

public class Service {
 public void processData() {
 throw NotImplementedException.forMethod("Service", "processData");
 }
 
 public void validateData(Data data) {
 try {
 // Валидация данных
 } catch (ValidationException ex) {
 throw new NotImplementedException("Service.validateData()", ex);
 }
 }
}

public abstract class BaseProcessor {
 public void process(Data data) {
 // Базовая реализация
 validate(data);
 doProcess(data);
 }
 
 protected abstract void doProcess(Data data);
 
 public void validate(Data data) {
 // Базовая валидация
 if (data == null) {
 throw new IllegalArgumentException("Data cannot be null");
 }
 }
 
 public void audit(Data data) {
 throw new NotImplementedException("BaseProcessor.audit() - auditing not implemented");
 }
}
 
public class SimpleProcessor extends BaseProcessor {
 @Override
 protected void doProcess(Data data) {
 // Конкретная реализация
 System.out.println("Processing data: " + data);
 }
 
 @Override
 public void audit(Data data) {
 // Конкретная реализация аудита
 System.out.println("Auditing data: " + data);
 }
}

import org.apache.commons.lang3.NotImplementedException;

public class OrderService {
 private final PaymentService paymentService;
 private final InventoryService inventoryService;
 private final NotificationService notificationService;
 
 public OrderService(PaymentService paymentService, 
 InventoryService inventoryService,
 NotificationService notificationService) {
 this.paymentService = paymentService;
 this.inventoryService = inventoryService;
 this.notificationService = notificationService;
 }
 
 public Order createOrder(OrderRequest request) {
 // Валидация запроса
 validateRequest(request);
 
 // Проверка наличия товара
 inventoryService.checkAvailability(request.getItems());
 
 // Обработка платежа
 PaymentResult paymentResult = paymentService.processPayment(request.getPayment());
 
 if (!paymentResult.isSuccess()) {
 throw new PaymentException("Payment failed");
 }
 
 // Создание заказа
 Order order = new Order();
 // ... логика создания заказа
 
 // Уведомление клиента - временно не реализовано
 try {
 notificationService.sendOrderConfirmation(order);
 } catch (NotificationException ex) {
 throw new NotImplementedException("OrderService.sendOrderConfirmation() - notification service integration incomplete", ex);
 }
 
 return order;
 }
 
 private void validateRequest(OrderRequest request) {
 if (request == null) {
 throw new IllegalArgumentException("Order request cannot be null");
 }
 // Другие проверки
 }
 // Другие методы
}

public class NotImplementedException extends RuntimeException {
 private final String methodName;
 private final String className;
 private final String suggestedImplementation;
 
 public NotImplementedException(String className, String methodName) {
 this(className, methodName, null);
 }
 
 public NotImplementedException(String className, String methodName, String suggestedImplementation) {
 super(String.format("Method %s.%s() is not implemented", className, methodName));
 this.className = className;
 this.methodName = methodName;
 this.suggestedImplementation = suggestedImplementation;
 }
 
 public NotImplementedException(String className, String methodName, Throwable cause) {
 this(className, methodName, null, cause);
 }
 
 public NotImplementedException(String className, String methodName, 
 String suggestedImplementation, Throwable cause) {
 super(String.format("Method %s.%s() is not implemented", className, methodName), cause);
 this.className = className;
 this.methodName = methodName;
 this.suggestedImplementation = suggestedImplementation;
 }
 
 // Factory method для улучшенной читаемости
 public static NotImplementedException withSuggestion(String className, String methodName, 
 String suggestion) {
 return new NotImplementedException(className, methodName, suggestion);
 }
 
 // Геттеры
 public String getMethodName() { return methodName; }
 public String getClassName() { return className; }
 public String getSuggestedImplementation() { return suggestedImplementation; }
 
 @Override
 public String getMessage() {
 String baseMessage = super.getMessage();
 if (suggestedImplementation != null) {
 return baseMessage + ". Suggested implementation: " + suggestedImplementation;
 }
 return baseMessage;
 }
}

public class ApiService {
 public ApiResponse callExternalService(Request request) {
 throw NotImplementedException.withSuggestion(
 "ApiService", 
 "callExternalService", 
 "Implement HTTP client integration with external API endpoints"
 );
 }
}

// Слой сервиса
@Service
public class UserService {
 public User getUserById(Long id) {
 try {
 User user = userRepository.findById(id)
 .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id));
 
 // Временная заглушка для бизнес-логики
 if (user.isActive()) {
 throw new NotImplementedException(
 "UserService.getUserById() - active user processing logic not implemented"
 );
 }
 
 return user;
 } catch (DataAccessException ex) {
 throw new NotImplementedException(
 "UserService.getUserById() - database access error", 
 ex );
 }
 }
}

// Глобальный обработчик исключений
@ControllerAdvice
public class GlobalExceptionHandler {
 
 @ExceptionHandler(NotImplementedException.class)
 public ResponseEntity<ErrorResponse> handleNotImplementedException(NotImplementedException ex) {
 ErrorResponse error = new ErrorResponse(
 "NOT_IMPLEMENTED", 
 ex.getMessage(),
 "This feature is not available yet. Please contact support for more information."
 );
 
 // Логирование для отслеживания не реализованных методов
 logger.warn("Method not implemented: {}.{}()", 
 ex.getClassName(), ex.getMethodName());
 
 return new ResponseEntity<>(error, HttpStatus.NOT_IMPLEMENTED);
 }
}