<?php // app/Exceptions/DomainException.php

namespace App\Exceptions;

use Exception;
use RuntimeException;

class DomainException extends RuntimeException
{
    protected $args;

    // PHP 내장 예외에서 string $message를 첫 인자로 받는 반면
    // 우리 클래스에서는 array $args를 첫 인자로 받는다.
    public function __construct(
        array $args, int $code = 0, Exception $previous = null
    )
    {
        $this->args = $args;
        
        // 배열로 받은 첫 인자를 문자열로 바꾸어
        // 부모 예외의 생성자를 호출한다.
        $message = $this->buildMessage($args);
        parent::__construct($message, $code, $previous);
    }

    public function getArgs()
    {
        return $this->args;
    }

    // 앞서 말한 배열을 문자열로 바꾸는 메서드다.
    // 문자열 패턴에 관한 관례가 있다면 맞추어서, 없다면 자유롭게 만들면 된다.
    protected function buildMessage(array $args = [])
    {
        $flattened = array_dot($args);
        $argKeys = array_keys($flattened);
        $argValues = array_values($flattened);

        $stringified = array_map(function ($key, $value) {
            return sprintf('[%s] %s.', $key, $value);
        }, $argKeys, $argValues);

        // 이 예제에서는 
        // ['foo' => 'bar', 'baz' => 'qux'] 라면 [foo] bar. [baz] qux.
        // ['foo' => ['key' => 'bar'], 'baz' => ['key' => 'qux']] 라면 [foo.key] bar. [baz.key] qux.
        // 처럼 바꾸어 준다.
        return implode(' ', $stringified);
    }
}

<?php // app/Exceptions/CustomDomainException.php

namespace App\Exceptions;

class CustomDomainException extends DomainException
{

}

<?php

$source = '/path/to/file';
$target = '/path/to/file.zip';
$compressor = new Compressor('zip');
$storage = new Storage('storage');

try {
    $compressed = $compressor->zip($path);
    $storage->put($target, $compressed);
} catch (DiskFullException $e) {
    // 디스크를 버리고 다시 시도 하는 등의 예외 처리를 하고
    // 사용자에게 실패를 알리기 위해서 HttpException을 다시 던진다.
    throw new FileCompressionFailed([
        'message' => '파일을 압축하지 못했습니다.',
        'reason' => $e->getMessage(),
    ], 500, $e);
}

<?php // app/Exceptions/HttpDomainException.php

namespace App\Exceptions;

use App\Classifiable;
use App\LogLevel;
use Exception;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;

class HttpDomainException extends DomainException implements HttpExceptionInterface, Classifiable
{
    protected $statusCode = 400;
    private $headers = [];

    // 2.1 절 대비 $statusCode, $headers 두 개의 생성자 인자가 더 추가되었다.
    public function __construct(
        array $args = [], int $statusCode = null,
        array $headers = [], int $code = 0, Exception $previous = null
    )
    {
        if (! is_null($statusCode)) {
            // 자식 클래스에서 프로퍼티로 정의한 값을 덮어쓰기 하지 않기 위한 조치다.
            $this->statusCode = $statusCode;
        }

        if (! empty($headers)) {
            // 자식 클래스에서 프로퍼티로 정의한 값을 덮어쓰기 하지 않기 위한 조치다.
            $this->headers = $headers;
        }

        parent::__construct($args, $code, $previous);
    }

    // 이하는 인터페이스를 구현한 메서드들이다.

    public function setStatusCode(int $statusCode = null)
    {
        $this->statusCode = $statusCode;

        return $this;
    }

    public function getStatusCode()
    {
        return $this->statusCode;
    }

    public function setHeaders(array $headers = [])
    {
        $this->headers = $headers;

        return $this;
    }

    public function getHeaders()
    {
        return $this->headers;
    }

    public function getLogLevel()
    {
        return LogLevel::getInstance('DEBUG');
    }
}

<?php // app/Exceptions/CustomHttpException.php

namespace App\Exceptions;

use App\Classifiable;
use App\LogLevel;

class CustomHttpException extends HttpDomainException implements Classifiable
{
    // 클래스에서 HTTP 응답 코드를 하드코드로 선언하고 있다.
    // 이 예외가 사용되는 경우는 항상 일관된 410 응답을 줄 수 있다. 
    protected $statusCode = 410;

    // Classifiable 인터페이스를 구현한 메서드다.
    // LogLevel::$name 속성이 설정된 객체를 반환한다.
    public function getLogLevel()
    {
        return LogLevel::getInstance('DEBUG');
    }
}

<?php // app/Classifiable.php

namespace App;

interface Classifiable
{
    // 이 인터페이스를 구현한 클래스는 이 메서드를 반드시 제공해야 한다.
    public function getLogLevel();
}

<?php // app/LogLevel.php

namespace App;

final class LogLevel
{
    // RFC3164 규격에 따른 에러 및 로깅 레벨이다.
    // @see https://tools.ietf.org/html/rfc3164
    const EMERGENCY = 0;
    const ALERT = 1;
    const CRITICAL = 2;
    const ERROR = 3;
    const WARNING = 4;
    const NOTICE = 5;
    const INFORMATIONAL = 6;
    const DEBUG = 7;

    // 여기에는 'DEBUG', 'WARNING'과 같은 문자열이 담긴다.
    private $name;

    // Static Constructor(생성자)다.
    // LogLevel::genInstance() 문장으로 클래스 인스턴스를 편리하게
    // 얻기 위한 도우미 메서드다.
    public static function getInstance(string $name = null)
    {
        // 아래에 정의된 진짜 생성자를 보면 이해하기 쉬울 것이다.
        // 결국 이 클래스의 $name 프로퍼티가 설정된 객체를 반환한다.
        return new static($name);
    }

    // $name 프로퍼티에 설정된 문자열을 조회한다.
    public function getName()
    {
        if (is_null($this->name)) {
            return null;
        }

        return $this->name;
    }

    // $name 프로퍼티에 설정된 문자열 값에 대칭되는 상수의 값을 조회한다.
    // 가령 $name에 'DEBUG'가 담겨 있다면, 이 메서드의 반환값은 7이다.
    public function getValue()
    {
        return constant("static::{$this->name}");
    }
    
    // 이 클래스의 진짜 생성자다.
    // private로 가시성을 선언해서, 외부에서 new 키워드로 인스턴스를 만들 수 없다.
    private function __construct($name = null)
    {
        if (is_null($name)) {
            // 생성자로 넘어온 인자가 없으면 'DEBUG'를 기본값으로 설정한다.
            $this->name = 'DEBUG';

            // 다음 로직으로 더 진행하지 않도록 Early Retrun 한다.
            return;
        }

        if (!defined('static::' . $name)) {
            // 생성자로 넘어온 인자에 해당하는 상수가 정의되어 있는 지 확인한다.
            // validate()와 같은 별도의 메서드로 추출하면 좋을 것 같다.
            throw new \InvalidArgumentException(
                sprintf('정의되지 않은 상수입니다. "%s:%s"', get_called_class(), $name)
            );
        }

        $this->name = $name;
    }
}

<?php // routes/web.php

Route::group(['prefix' => 'exceptions'], function () {
    Route::get('domain', function () {
        throw new \App\Exceptions\DomainException([
            'foo' => 'bar', 'baz' => 'qux'
        ]);
    });

    Route::get('custom-domain', function () {
        throw new \App\Exceptions\CustomDomainException([
            'foo' => 'bar', 'baz' => 'qux'
        ]);
    });

    Route::get('http-domain', function () {
        throw new \App\Exceptions\HttpDomainException([
            'foo' => 'bar', 'baz' => 'qux'
        ]);
    });

    Route::get('custom-http', function () {
        // HttpExceptionInterface를 구현한 부모를 상속 받고 있으므로
        // setStatusCode() 메서드를 이용해서 CustomHttpException::$statusCode
        // 프로퍼티를 덮어 쓸 수 있다.
        throw (new \App\Exceptions\CustomHttpException([
            'foo' => 'bar', 'baz' => 'qux'
        ]))->setStatusCode(409);
    });

    Route::get('model-not-found', function () {
        // ModelNotFoundException도 setModel() 메서드를 이용해서
        // 런타임에 모델과 모델의 기본키를 설정할 수 있도록 구현되어 있다.
        // 참고로 이 예외는 라라벨 프레임워크에서 제공하는 예외이며,
        // User::findOrFail($notExistingId)를 호출했을 때 발생한다.
        throw (new \Illuminate\Database\Eloquent\ModelNotFoundException)
            ->setModel(\App\User::class, 1);
    });
});

<?php // app/Exceptions/Handler.php

namespace App\Exceptions;

use App\Classifiable;
use App\LogLevel;
use Exception;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Psr\Log\LoggerInterface;

class Handler extends ExceptionHandler
{
    // ...
    
    public function report(Exception $exception)
    {
        // Classifiable 인터페이스를 구현한 예외 객체라면 
        // getLogLevel() 메서드를 쓸 수 있다는 것을 확인할 수 있다.
        if ($exception instanceof Classifiable) {
            // 라라벨 5.2 까지는 부모 클래스에서 주입 받은 $this->logger를 쓸 수 있었으나
            // 라라벨 5.3 부터는 MonoLog 인스턴스를 직접 만들어야 한다.
            $logger = $this->container->make(LoggerInterface::class);
            $logLevel = $exception->getLogLevel();
            
            // case 구문을 7개나 써야 하는 번거로움을 피하기 위해 메타 프로그래밍을 했다.
            // 'DEBUG' -> 'debug' 로 문자열을 트랜스폼한다.
            $method = strtolower($logLevel->getName());
            
            // 아래 문장은 $logger->debug($exception)와 같다.
            call_user_func([$logger, $method], $exception);

            if ($logLevel->getValue() <= LogLevel::ERROR) {
                // 심각도가 높은 예외가 발생했다. 관리자에게 알림을 보내거나 SaaS 서비스에
                // 로그를 등록하는 등의 특별한 리포팅 작업을 이 곳에서 수행할 수 있다.
            }
        } else {
            // 부모 클래스의 기본 동작은 라라벨 로그에 내용을 기록하는 것이다.
            parent::report($exception);
        }
    }
}

<?php

namespace App\Exceptions;

use Exception;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Illuminate\Http\Response;

class Handler extends ExceptionHandler
{
    public function render($request, Exception $exception)
    {
        if ($exception instanceof HttpDomainException) {
            // HttpDomainException 인터페이스를 구현했다면
            // getStatusCode() 메서드를 쓸 수 있다는 것을 확인할 수 있다.
            $statusCode = $exception->getStatusCode();

            return response()->json(
                [
                    'code' => $statusCode,
                    'error' => (object) $exception->getArgs(),
                ],
                $statusCode, $exception->getHeaders()
            );
        } elseif ($exception instanceof DomainException) {
            // 응답 코드를 강제로 500으로 바꿨다.
            $statusCode = Response::HTTP_INTERNAL_SERVER_ERROR;

            return response()->json(
                [
                    'code' => $statusCode,
                    'error' => (object) $exception->getArgs(),
                ],
                $statusCode
            );
        } elseif ($exception instanceof ModelNotFoundException) {
            // 응답 코드를 404로 바꿨다.
            $statusCode = Response::HTTP_NOT_FOUND;

            return response()->json(
                [
                    'code' => $statusCode,
                    'error' => $exception->getMessage(),
                ],
                $statusCode
            );
        }

        return parent::render($request, $exception);
    }
}

<?php // tests/ExpectExceptionTest.php

class ExpectExceptionTest extends TestCase
{
    public function testDomainException()
    {
        $this->expectException(App\Exceptions\DomainException::class);
        $this->visit('exceptions/domain');
    }
}

<?php // app/Exceptions/Handler.php

namespace App\Exceptions;

class Handler extends ExceptionHandler
{
    // ...
    
    public function render($request, Exception $exception)
    {
        // 적절한 렌더링 클래스 선택을 getRenderingStrategy() 메서드에게 위임한다.
        return $this->getRenderingStrategy($request, $exception)
            ->render($request, $exception);
    }
    
    protected function getRenderingStrategy($request, Exception $exception)
    {
        // 적절한 객체를 선택하고 만들어서 반환하는 Factory다.
        if ($exception instanceof HttpDomainException) {
            return new \App\Exceptions\Renderers\HttpDomainException;
        } elseif ($exception instanceof DomainException) {
            return new \App\Exceptions\Renderers\DomainException;
        } elseif ($exception instanceof ModelNotFoundException) {
            return new \App\Exceptions\Renderers\ModelNotFoundException;
        }

        // render() 메서드에서 return 구문을 쓰고 있고,
        // if 제어를 제거했으므로 return parent::render()를 실행할 방법이다.
        // 다른 녀석들 처럼 render() 메서드를 쓸 수 있는 객체를 반환하면 되는데,
        // 라라벨의 컨테이너에서 부모 클래스 객체를 Resolve하고 반환했다.
        return app(get_parent_class($this));
    }
}

<?php // app/Exceptions/Renderers/HttpDomainException.php

namespace App\Exceptions\Renderers;

use Exception;

class HttpDomainException implements Renderable
{
    public function render($request, Exception $exception)
    {
        $statusCode = $exception->getStatusCode();

        return response()->json(
            [
                'code' => $statusCode,
                'error' => (object) $exception->getArgs(),
            ],
            $statusCode, $exception->getHeaders()
        );
    }
}

<?php // app/Exceptions/Renderers/Renderable.php

namespace App\Exceptions\Renderers;

interface Renderable
{
    public function render($request, \Exception $exception);
}