Creating Effective Exceptions in Java Code [Video]

This article will explore the critical topic of creating effective exceptions in your Java code. Exceptions are crucial in identifying when something goes wrong during code execution. They are instrumental in managing data inconsistency and business validation errors. We will outline three key steps for writing effective exceptions in your Java code.

1. Writing and Defining an Exception Hierarchy
2. Creating a Trackable Exception Message
3. Avoiding Security Problems with Exceptions

1. Writing and Defining an Exception Hierarchy

Define the exception hierarchy as the first step in your design process. By considering the domain, you can begin with more general exceptions and then move towards more specific ones. This approach enables you to trace issues using the hierarchy tree or exception names.

As emphasized in Domain-Driven Design (DDD), meaningful names are also important for exception names. For example, in the domain of credit cards, you can start with a generic organization exception, then move to a domain-specific exception like credit card exceptions, and finally, to specific errors.

Here’s an example:

public class MyCompanyException extends RuntimeException {
    public MyCompanyException(String message) {
        super(message);
    }

    public MyCompanyException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class CreditCardException extends MyCompanyException {
    public CreditCardException(String message) {
        super(message);
    }

    public CreditCardException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class CreditCardNotFoundException extends CreditCardException {
    public CreditCardNotFoundException(String message) {
        super(message);
    }

    public CreditCardNotFoundException(String message, Throwable cause) {
        super(message, cause);
    }
}

With this hierarchy, if an exception is thrown, we know it belongs to the credit card domain, which is part of the organization’s exceptions.

2. Creating a Trackable Exception Message

The second step is to make the exception message trackable. While creating a well-structured hierarchy is essential, it’s equally important to provide detailed messages that can help identify the exact issue. For instance, in a service that processes credit card payments, including the credit card ID in the exception message can be very helpful.

public void pay(UUID creditCardId, Product product) {
    LOGGER.info("Paying with credit card: " + creditCardId);
    LOGGER.fine("Paying for product: " + product);

    findById(creditCardId).orElseThrow(() -> new CreditCardNotFoundException("Credit card not found with the id: " + creditCardId));
}

In this example, if the credit card is not found, the exception message will include the ID, making it easier to understand why the error occurred and to check why this information is missing.

3. Avoiding Security Problems With Exceptions

Security is a critical aspect of exception handling. Ensure that the exception messages do not contain sensitive information that could lead to data breaches. Like best logging practices, you should avoid exposing critical data in exception messages.

For example, instead of including sensitive details in the exception, provide a generic message and log the details securely:

public void pay(UUID creditCardId, Product product) {
    LOGGER.info("Paying with credit card: " + creditCardId);
    LOGGER.fine("Paying for product: " + product);

    findById(creditCardId).orElseThrow(() -> {
        LOGGER.severe("Credit card not found with id: " + creditCardId); // Detailed log
        return new CreditCardNotFoundException("Credit card not found"); // Generic message
    });
}

Additional Resources

For further learning, you can watch the complimentary video below.

Access the source code here:

• GitHub - Java Exception Handling Code

Following these steps, you can create a robust exception-handling mechanism in your Java applications, making your code more maintainable, secure, and easier to debug.

Video