How can I hide ugly implementation details (i.e. try/catch blocks)?

Question

I am adding exception handling to my PHP code. It seems that I end up with lots of sparse blocks that do exception handling and by their sheer bulkiness hide the actual production code that is being run. For example:

function loadProduct($id)
{
    $product = new ProductRecord();

    try 
    {
        $data = $product->loadFromDatabase($id);
    }
    catch (\BadFunctionCallException $e)
    {
        $error = true;
    }        

    return $data;
}

the actual payload of the above function is to return the $data. Without the exception handling it could be a 2-line function:

function loadProduct($id)
{
    $product = new ProductRecord();
    return $product->loadFromDatabase($id);
}

One way to hid this is to use Factory Method, such as:

function loadProduct($id)
{
    $product = new ProductRecord();
    $factory = new ProductFactory($product);
    return $factory->loadProduct($id);  //inside loadProduct I can put try/catch block
}

Here I am adding a whole new (factory) class and another line of code in my function to hide my exception handling. With proper care I think this will work and still look good (i.e. I can initialize my factory inside the constructor, thus moving it out of the function-level code, so it can be a good option). But is that the best?

In other words, my question is -- how can I use Exception Handling in my code without burying my actual payload into the sparseness of try/catch blocks?

Answer 1

Here is an example, how to solve your issue with Go! AOP framework and Around advice:

/**
 * This advice intercepts an execution of some methods
 *
 * Logic is pretty simple: we wrap an original method with our advice
 * and catch all exceptions in one place.
 *
 * @param MethodInvocation $invocation Invocation
 *
 * @Around("execution(public SomeClassName->*(*)")
 */
public function aroundPublicMethods(MethodInvocation $invocation)
{
    try {
        $result = $invocation->proceed(); // invoke original method
    } catch (\Exception $e) {
        $result = $e; // exception will be returned as a result to method call
    }

    return $result;
}

That's it.

Answer 2

One way could be AOP, another could be using an IOC and kernel like middleware like StackPHP and just have exception handling as another middleware layer. Of course you cant do that if you're using exceptions for control flow, unless its at the entire request response level.