Java中受检异常的通用性该如何把握？选UserNotFoundException还是EntityNotFoundException？

Hey there! Let's break down your questions one by one—this is a super common (and smart) concern when designing exception hierarchies, especially in Java.

The key here is striking a balance between too vague and too granular:

• Avoid overly generic exceptions like just throwing Exception—they give zero context to whoever's catching them, making it impossible to handle specific errors properly.
• Don't go the opposite extreme either, creating a unique exception for every tiny edge case (like UserEmailNotFoundInDatabaseException). This bloats your codebase and forces developers to track dozens of similar exceptions.
• The sweet spot? Align the exception's scope with business semantics and handling logic. If two error scenarios require the exact same recovery or logging behavior, a shared generic exception makes sense. If they need different handling (e.g., "user not found" triggers a registration prompt vs "order not found" triggers a refund flow), use specific exceptions instead.

Since checked exceptions force callers to either catch or declare them, you need to be extra intentional with their scope:

• Leverage standard JDK exceptions first: Don't reinvent the wheel for common cases. Use IllegalArgumentException for invalid inputs, IOException for I/O failures, etc.—these are universally understood.
• Tie generic checked exceptions to recoverable, uniform scenarios: If a set of operations all face a recoverable error that callers can handle the same way (e.g., "external service unavailable" where retry is the fix), a generic checked exception works. But if some cases need retries and others need user notifications, split them into specific exceptions.
• Avoid overly broad checked exceptions: If you define a ServiceException that covers every possible error in your service layer, callers will have to catch it and then do messy instanceof checks to handle specific cases—defeating the purpose of checked exceptions.

It all depends on your system's context and how you handle "not found" errors:

• Use UserNotFoundException if users are a distinct, high-priority entity with unique handling: If "user not found" triggers specific logic (like redirecting to a signup page, logging user-specific metrics, or returning a custom 404 message), this specific exception makes your code more readable and ensures handlers can target this exact scenario without extra checks.
• Use EntityNotFoundException if you have multiple entities with identical "not found" handling: If users, orders, products, etc., all result in the same action when missing (e.g., a generic 404 response, a standard log entry), this generic exception keeps your code DRY. Just add context to the exception (e.g., new EntityNotFoundException("User", userId)) so logs and error messages still have meaningful details.
• Pro tip: If you're building a shared DAO or framework layer, EntityNotFoundException is better because it's decoupled from specific business entities. For user-specific service logic, stick with UserNotFoundException for clarity.

内容的提问来源于stack exchange，提问作者Sean