Não é novidade, mas vale o registro. O PHP 5, possui uma funcionalidade bem interessante, similar a outras linguagens orientadas a objeto, Exceção. Quando algo altera o fluxo de execução do sistema ele dispara uma Exceção. Uma exceção pode ser disparada ou capturada, depende do que você pretende. Você pode customizar um série de tratamentos de erros que irão facilitar o desenvolvimento do seu sistema, com essa custimização você pode saber exatamente o que está sendo tratado e se algo fugir desse controle é algo anormal e fica mais facil a rastreabilidade.
Dentro de uma exceção, você pode disparar um log, ou um alert, ou registrar algo no banco, é um fluxo de erro sob controle.
Eu costumo tratar as exceções para tudo, campo em branco, tipo de dado inválido, e-mail inválido, ou se alguma fórmula não foi validada. Para isso uso um conjunto de classes que constituem as mensagens e os testes para que as exceções sejam disparadas:
Uma classe Main para controlar as requisições de Exception:
MainException.php:
<?PHP
/**
* Declaração da classe para tratamento de erros
* A classe deve ser extendida da classe Exception do PHP
* Ela irá realizar a sobrescrita da classe Exception do PHP
*/
class MainException extends Exception {
//Faço a declaração das variávis que vou utilizar no corpo da classe
private $cod = 0;
private $msg = "";
private $erromsg = "";
/**
* Aqui faço a declaração do método construtor de classe
* Esse método recebe os seguintes parametros:
* @param $cod – Código de erro
* @param $msg – Uma mensagem de erro personalizada
* @param $erromsg – Uma mensagem de erro padrão
*/
public function __construct( $cod = 0 , $msg = "" , $erromsg = "" ) {
//Sobreescrevo as propiedades da classe passando os parametros
$this->cod = $cod;
$this->msg = "Ocorreu um erro não identificado";
$this->erromsg = $erromsg;
//Aqui eu chamo o construtor da classe pai
parent::__construct( $this->msg , $this->cod );
}
/**
* Este método irá salvar nossos erros em um log
*/
public function _Log() {
//Define o arquivo que será criado ou gravado caso exista, o nome do arquivo irá ser o nome da classe
$log = __CLASS__ . "_log_" . date("dmY") . "txt";
//Se não existe arquivo, cria
if( !file_exists($log)){
$msg = "/************************************************** " .
" * Arquivo de log " .
" * " .
" * ClassName: " . __CLASS__ . " " .
" * Data Criação: " . date("d/m/Y H:i") . " " .
" *************************************************/ " .
"——————————————————————- ";
}else
$msg = "";
//Abre o arquivo
if($fp = fopen( $txt , "a+")) {
//Arquivo
$msg .= __CLASS__ . " hora: ".date("H:i") . " " .
"Erro [ {$this->cod} ]: linha ( {$this->line} ) " .
"{$this->msg} " .
"{$this->erromsg} " .
"——————————————————————- ";
//Grava
fwrite($fp, $msg);
fclose($fp);
}
}
}
?>
A classe abaixo estende MainException e a customiza para Exceções de texto:
textException.php:
<?PHP
/**
* Esta classe é responsável por disparar exceções relacionadas a texto
*/
class textException extends MainException {
public function __construct( ) {
//Sobrescrita do construtor de MainException, com os valores que queremos
parent::__construct( 1, "Tipo de caracter inválido", PHPSELF);
$this->_Log();
}
}
?>
A classe abaixo faz a verificação do texto e dispara a exceção:
verificaTexto.php:
<?PHP
class verificaTexto
{
public function __construct($texto)
{
if(!is_int($texto))
{
echo $texto;
}
else
{
throw new textException();
}
}
}
?>
A classe abaixo faz o teste para números e caso falhe, dispara MainException, ou seja sem customizar o tipo de exceção que será disparada, então irá enviar a mensagem padrão:
verificaValor.php:
<?PHP
class verificaValor
{
public function __construct($val)
{
if($val == 1)
{
echo $val;
}
else
{
throw new MainException();
}
}
}
?>
Apenas para teste:
<?PHP
include ("autoload.php");
try
{
//$b = new verificaTexto(1);
$b1 = new verificaValor(1123);
}
Catch(textException $te)
{
echo $te->getMessage();
}
catch(Exception $e)
{
echo $e->getMessage();
}
?>
E o autoload se alguém quiser:
<?PHP
function __autoload($class_name) {
require_once $class_name . ‘.php’;
}
?>
Como podem ver, a classe MainException é que faz todo o trabalho, nela temos o método principal que realiza o disparo das exceptions, em textException, sobrespcrevemos a classe MainException e fazemos ela se comportar como queremos para disparar apenas uma mensagem de erro para textos.
Ainda existe a possibilidade de disparar uma Exception genérica, caso nosso tratamento não seja para textos. Se observarem com calma verão que se trata apenas de sobrescritas de métodos algo que seria perfeitamente possível sem Exception, porém desta forma temos mais controle (fora a elegancia do código).
Bom é isso, qualquer dúvida comentem.
Para saber mais:
Tags BlogBlogs: php, exception, oo
