Como desenvolvedor PHP, talvez use exceções por elas permitirem que você saiba quando algo errado aconteceu ou o quando o usuário agiu de forma não esperada (como tentar dividir números por zero) em sua aplicação. Sem o uso de exceções, sua aplicação acabaria apresentando erros indesejáveis e seria muito mais difícil de depurar. Também é importante pausar a execução e realizar outra ação em caso de exceção.
Exceções são simples de entender e facilitarão o progresso do seu desenvolvimento. Quando aprender a usar exceções, verá que elas serão algo comum no seu desenvolvimento.
O Que É uma Exceção?
Acredito que a melhor definição para exceções foi dita pelo Martin Fowler:
Exceções sinalizam algo fora do comportamento esperado de um dado trecho de código.
Mais precisamente, uma exceção é um evento que acontece durante a execução de um programa, quebrando o fluxo normal das instruções do mesmo. Quando você usa uma exceção (criando um objeto e passando para o sistema em execução) através do throw, o sistema irá capturá-la (através do catch) e buscará o manipulador de exceção adequado para ela e retornará a mensagem correta.
1
2
3
4
5
6
try{
// the code goes here
} catch(Exception $e) {
// if an exception happened in the try block above
}
Quando Precisamos Usar Exceções?
Use exceções quando se deparar com circunstâncias excepcionais que previnam a execução normal do sistema. Usamos exceções apenas quando o sistema não for capaz de determinar o que aconteceu. Martin Fowler acredita que "se uma falha é um comportamento esperado, não se deve usar exceção para ela". Isso significa que só deve, realmente, usar exceções quando não puder determinar o erro. Exceções deveriam ser usadas apenas em casos raros.
Nota: Exceções não são boas para manipular operações lógicas.
Para um sistema que valida dados de entrada, é errado usar exceções. Primeiro, o campo de texto é algo que conhecemos e, em uma aplicação como essa, devemos reportar um conjunto de erros ao invés de um único erro. Sou dos que acreditam que não se deve usar exceções em casos onde podemos esperar por erros de validação.
Capturar uma exceção é bastante importante, já que, caso isso ocorra, o sistema resultará em um erro. A operação de captura deve ser realizada tão logo quando a exceção ocorra.
Exceções no Laravel
O Laravel usa um manipulador de exceções, que é uma classe no arquivo App\Exceptions\Handler.php. Essa classe contém dois métodos principais (o método renderHttpException, que é usado para todas exceções HTTP, como os erros 404 e 503, fica na classe pai do manipulador). O primeiro é o report, que é usado para registrar exceções ou enviá-las para um serviço externo. Eis um exemplo do método report:
1
2
3
4
5
6
7
8
publicfunctionreport(Exception $e)
{
if($einstanceofCustomException) {
//
}
returnparent::report($e);
}
O segundo é o render. O método render é responsável por converter uma dada exceção em uma resposta HTTP que deve ser enviada de volta para o navegador. Eis um exemplo do método render:
1
2
3
4
5
6
7
8
publicfunctionrender($request, Exception $e)
{
if($einstanceofCustomException) {
returnresponse()->view('errors.custom', [], 500);
}
returnparent::render($request, $e);
}
Nota: Você pode usar a propriedade $dontReport do manipulador de exceção para ignorar exceções de acordo com seus tipos.
Você pode sobrescrever os métodos de exceção do Laravel, com suas próprias exceções, dessa forma:
1
2
3
4
5
6
7
publicfunctionrender($request, Exception $e)
{
if(config('app.debug')) {
returnparent::render($request, $e);
}
return$this->handle($request, $e);
}
Isso será renderizado quando o modo de depuração estiver ativado.
Como Criar sua Prórpia Exceção no Laravel?
Talvez você tenha a necessidade de criar sua própria classe de exceção. Você precisará estender a classe base de Exceção do Laravel—criei uma classe abstrata que se comportará como a classe base para nossa classe de Exceção customizada. Crie o arquivo App/Exceptions/MyException.php:
Além da classe de Exceção padrão do Laravel, você pode usar o pacote Assertion. Ele pode ser usado como uma classe de exceção de externa, de forma a evitar enormes quantidades de blocos if em seu código.
Para instalar o pacote Assertion, você deve executar o seguinte comando:
1
composer require beberlei/assert
Por exemplo, se quiser verificar o endereço de e-mail de um usuário, você pode fazer assim:
1
2
3
4
5
6
7
8
9
useAssert\Assertion;
useAssert\AssertionFailedException;
//...
try{
Assertion::email($value, "The value must be valid E-mail address");
} catch(AssertionFailedException $e) {
$e->getValue(); // the value that caused the failure
$e->getConstraints(); // the additional constraints of the assertion.
}
***************************
O que são exceções?
Em geral, uma exceção é quando, durante o processamento de uma ação dentro do código, foge do esperado e requer um processamento especial. Dentro do PHP é possível usar o conceito de try… catch… finally.
<?php
try {
// code here
}
catch (Exception $e) {
// code for expcetion
}
finally {
// code to run either if successfull or failure
}
Por que utilizar exceções customizadas?
Ok, mas por que não utilizar a exception padrão da linguagem? Os motivos são bastante simples:
Fácil entendimento do erro: uma exceção deve mostrar de forma rápida e simples o motivo e origem do problema;
Adicionar informações relevantes: a fim de facilitar o debug, principalmente por outros desenvolvedores, no momento de realizar a correção;
Exceções genéricas não apontam o caminho a ser seguido: no momento do tratamento de uma exceção, trabalhar com exceções genéricas requerem a interpretação de um programador. Utilizando uma exceção não genérica, muitos dos problemas (inclusive mensagens de erro para o usuário final) podem se manipulados de forma mais eficiente.
Criando exceções no Laravel
Como tudo no Laravel, o artisan está aí para isso! O código abaixo ira gerar uma nova exceção dentro da pasta app/exceptions do seu projeto:
$ php artisan make:exception MyNewException
<?php
namespace App\Exceptions;
use Exception;
class MyNewExcpetion extends Exception
{
}
Por boas práticas, mantemos sempre o Exception no final do nome de nossa exceção. Isso facilitará para futuros desenvolvedores entenderem que o que ele está recebendo é de fato uma exceção.
O código gerado anteriormente, por si só, já estaria completo e poderiamos utilizar nossa exception e teriamos, caso o debug esteja ativado, o seguinte retorno:
App \ Exceptions \ MyNewException
My error message
Customizando minha exceção
Como todas as exceções são tratadadas, quando não tratadas, pela classe App\Exceptions\Handler do Laravel, podemos ir além! A classe utiliza duas ótimas funções para que o programador possa customizar ainda mais o comportamente da exceção:
report: permite customizar o envio da exceção para um gerenciador de erros (como Sentry, Bugsnag, etc);
render: exibe a exceção como uma resposta HTTP (ótimo para exceções que precisam ser mostradas de forma amigável para o usuário).
Podemos aplicar da seguinte forma dentro de nossa exceção criada anteriormente:
<?php
namespace App\Exceptions;
use Exception;
class MyNewExcpetion extends Exception
{
/**
* Report the exception.
*
* @return void
*/
public function report()
{
//
}
/**
* Render the exception into an HTTP response.
*
* @param \Illuminate\Http\Request
* @return \Illuminate\Http\Response
*/
public function render($request)
{
return response(...);
}
}
Veja também que é possível chegar no mesmo objetivo de forma genérica direto dentro da classe App\Exceptions\Handler alterando as funções ali presentes.
Ainda dentro do Handler do Laravel é possível customizar dois pontos:
Exceções que não devem ser reportadas: basta adicionar as classes dentro da variavel $dontReport;
Inputs que não devem persistir com o flash: que precisam ser adicionadas na variável $dontFlash.
Reportando uma exceção e continuando a execução
Em alguns casos, ao receber uma exceção, desejamos seguir algum outro caminho. Porém, pode ser interessante fazer o log dessa exceção para futura análise, sem prejudicar o funcionamento da plataforma.
Para isso, a framework disponibiliza um helper: report($exception)
Basta enviar a exceção para a função que ela executará o report da classe Handler.
Exceções HTTP
Para finalizar, o Laravel já vem com algumas páginas de erro HTTP padrão. Erros como 404 (páginas não encontrada) e 500 (erro interno do servidor) são apresentados para o usuário como uma página HTML:
Página 404 do Laravel 5.7
Para customizar as páginas de erro, basta criar dentro de resources/views/errors/ as páginas blade. Lembre-se que as páginas devem ser nomeadas de acordo com o status HTTP que deseja exibir. Ou seja, para uma página de erro 404, o arquivo deverá ser nomeado 404.blade.php.
Caso queira apenas dar uma mudada no padrão do Laravel, a framework permite publicar as páginas pré-existentes com o seguinte comando:
php artisan vendor:publish --tag=laravel-errors
As views serão adicionadas ao caminho das páginas de erro.
