Advertisement
  1. Code
  2. Laravel

Tratarea erorilor in Laravel

Scroll to top
Read Time: 8 min

Romanian (Română) translation by C. Dan (you can also view the original English article)

În acest articol, vom explora una dintre cele mai importante și cel mai puțin discutate caracteristici din cadrului framework-ului web Laravel — respectiv tratarea excepției. Laravel vine încorporat cu un mecanism de tratare a excepțiilor (exception handler), care vă va permite să raportați și să interpretați mai ușor excepțiile și într-un mod prietenos.

În prima jumătate a articolului, vom explora setările implicite furnizate de mecanismul de tratare a excepților. De fapt, vom parcurge clasa implicită "Handler", în primul rând pentru a înțelege cum tratează Laravel excepțiile.

În a doua jumătate a articolului, vom merge mai departe și vom vedea cum putem crea un mecanism de tratare a excepțiilor particularizat care va permite captarea excepții particularizate.

Configurarea cerințelor preliminare

Înainte de a merge mai departe pentru a cerceta neîntârziat clasa ”Handler”, haideți să aruncăm o privire la câțiva parametri importanți de configurare raportați la excepții.

In continuare deschideți fișierul config/app.php.  Să aruncăm o privire mai atentă la fragmentul următor.

1
...
2
...
3
/*

4
|--------------------------------------------------------------------------

5
| Application Debug Mode

6
|--------------------------------------------------------------------------

7
|

8
| When your application is in debug mode, detailed error messages with

9
| stack traces will be shown on every error that occurs within your

10
| application. If disabled, a simple generic error page is shown.

11
|

12
*/
13
14
'debug' => env('APP_DEBUG', false),
15
...
16
...

După cum sugerează și numele, dacă variabila este setată la TRUE, vă va ajuta să depanați erorile generate de aplicație. Valoarea implicită a acestei variabile este setată la valoarea variabilei de mediu APP_DEBUG în fișierul .env.

În mediul de dezvoltare, variabila ar trebui setată la TRUE, astfel încât să puteți urmări cu ușurință erorile și să le remediați. Pe de altă parte, este de dorit dezactivarea acesteia în mediul de producție, iar în acest caz va fi afișată o pagină generică de eroare.

 În plus față de afișarea erorilor, Laravel vă va permite să inregistrați erorile în fișierul jurnal. Haideți să aruncăm o scurtă privire la opțiunile disponibile pentru logare. Incă o dată, deschideți fișierul config/app. php și fiți atenți la următorul fragment.

1
...
2
...
3
'log' => env('APP_LOG', 'single'),
4
5
'log_level' => env('APP_LOG_LEVEL', 'debug'),
6
...
7
...

Deoarece Laravel utilizează pentru logare biblioteca Monolog PHP, ar trebui să setați opțiunile de mai sus în cadrul acelei biblioteci.

Fișierul jurnal implicit se regăsește la storage/logs/laravel.log  și de cele mai multe ori este suficient. Pe de altă parte, variabila APP_LOG_LEVEL este setată la o valoare care indică nivelul de severitate al erorilor care vor fi înregistrate.

Deci, aceasta a fost o introducere de bază la opțiunile de configurare disponibile pentru excepții și pentru logare.

Mergând mai departe, să aruncăm o privire la clasa implicită ”Handler” care este inclusă implicit în aplicația Laravel. Continuați și deschideți fișierul app/Exceptions/Handler.php.

1
<?php
2
3
namespace App\Exceptions;
4
5
use Exception;
6
use Illuminate\Auth\AuthenticationException;
7
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
8
9
class Handler extends ExceptionHandler
10
{
11
    /**

12
     * A list of the exception types that should not be reported.

13
     *

14
     * @var array

15
     */
16
    protected $dontReport = [
17
        \Illuminate\Auth\AuthenticationException::class,
18
        \Illuminate\Auth\Access\AuthorizationException::class,
19
        \Symfony\Component\HttpKernel\Exception\HttpException::class,
20
        \Illuminate\Database\Eloquent\ModelNotFoundException::class,
21
        \Illuminate\Session\TokenMismatchException::class,
22
        \Illuminate\Validation\ValidationException::class,
23
    ];
24
25
    /**

26
     * Report or log an exception.

27
     *

28
     * This is a great spot to send exceptions to Sentry, Bugsnag, etc.

29
     *

30
     * @param  \Exception  $exception

31
     * @return void

32
     */
33
    public function report(Exception $exception)
34
    {
35
        parent::report($exception);
36
    }
37
38
    /**

39
     * Render an exception into an HTTP response.

40
     *

41
     * @param  \Illuminate\Http\Request  $request

42
     * @param  \Exception  $exception

43
     * @return \Illuminate\Http\Response

44
     */
45
    public function render($request, Exception $exception)
46
    {
47
        return parent::render($request, $exception);
48
    }
49
50
    /**

51
     * Convert an authentication exception into an unauthenticated response.

52
     *

53
     * @param  \Illuminate\Http\Request  $request

54
     * @param  \Illuminate\Auth\AuthenticationException  $exception

55
     * @return \Illuminate\Http\Response

56
     */
57
    protected function unauthenticated($request, AuthenticationException $exception)
58
    {
59
        if ($request->expectsJson()) {
60
            return response()->json(['error' => 'Unauthenticated.'], 401);
61
        }
62
63
        return redirect()->guest(route('login'));
64
    }
65
}

Există două funcții importante pentru care clasa ”Handler” este responsabilă — raportarea și redarea tuturor erorilor.

Să ne uităm mai atent și la metoda report.

1
/**

2
 * Report or log an exception.

3
 *

4
 * This is a great spot to send exceptions to Sentry, Bugsnag, etc.

5
 *

6
 * @param  \Exception  $exception

7
 * @return void

8
 */
9
public function report(Exception $exception)
10
{
11
    parent::report($exception);
12
}

Metoda ”report” este utilizată pentru a înregistra erorile în fișierul jurnal. În același timp este important de reținut proprietatea dontReport  care listează toate tipurile de excepții ce nu ar trebui să fie înregistrate.

In continuare, să supunem atenției metoda render.

1
/**

2
 * Render an exception into an HTTP response.

3
 *

4
 * @param  \Illuminate\Http\Request  $request

5
 * @param  \Exception  $exception

6
 * @return \Illuminate\Http\Response

7
 */
8
public function render($request, Exception $exception)
9
{
10
    return parent::render($request, $exception);
11
}

Dacă metoda report este utilizată pentru a înregistra sau raporta erori, metoda render este utilizată pentru a afișa erorile pe ecran. De fapt, această metodă tratează ce se va afișa utilizatorilor atunci când se produce excepția.

De asemenea, metoda render vă va permite să particularizați un răspuns pentru diferite tipuri de excepții, după vom vedea în secțiunea următoare.

În cele din urmă, metoda unauthenticated tratează excepția AuthenticationException care vă va permite să decideți ce va fi afișat utilizatorilor în cazul în care aceștia sunt neautentificați pentru a accesa o pagină pe care o caută.

Clasa ”Exception” particularizată

În această secțiune, vom crea o clasă de excepție particularizată care tratează excepțiile de tip CustomException. Ideea din spatele creării de clase de excepție particularizate este de a gestiona cu ușurință excepțiile particularizate și de a genera răspunsuri particularizate în același timp.

In continuare creați un fișier  app/Exceptions/CustomException.php cu următorul conținut.

1
<?php
2
3
namespace App\Exceptions;
4
5
use Exception;
6
7
class CustomException extends Exception
8
{
9
    /**

10
     * Report the exception.

11
     *

12
     * @return void

13
     */
14
    public function report()
15
    {
16
    }
17
18
    /**

19
     * Render the exception into an HTTP response.

20
     *

21
     * @param  \Illuminate\Http\Request

22
     * @return \Illuminate\Http\Response

23
     */
24
    public function render($request)
25
    {
26
        return response()->view(
27
                'errors.custom',
28
                array(
29
                    'exception' => $this
30
                )
31
        );
32
    }
33
}

Cel mai important lucru de reținut aici este referitor la clasa CustomException care trebuie să extindă clasa de bază Exception. În scopuri demonstrative, vom discuta doar metoda de randare, dar desigur, ați putea personaliza și metoda ”report”.

După puteți vedea, în cazul nostru utilizatorii sunt redirecționați către pagina de erori errors.custom. În acest fel, aveți posibilitatea să implementați pagini particularizate de eroare  pentru anumite tipuri de excepții.

Desigur, trebuie să creăm un fișier de vizualizare asociat la resources/views/errors/custom.blade.php.

1
Exception details: <b>{{ $exception->getMessage() }}</b>

Acesta este un fișier de vizualizare destul de simplu, care afișează un mesaj de eroare, dar desigur, ați putea proiecta-o așa cum doriți să fie.

De asemenea, trebuie să facem modificări în metoda de randare a fișierului app/Exceptions/Handler.php astfel încât clasa noastră personalizată de excepție  să poată fi invocată. Să înlocuim metoda de randare cu următorul conținut din fișierul app/Exceptions/Handler.php.

1
...
2
...
3
/**

4
 * Render an exception into an HTTP response.

5
 *

6
 * @param  \Illuminate\Http\Request  $request

7
 * @param  \Exception  $exception

8
 * @return \Illuminate\Http\Response

9
 */
10
public function render($request, Exception $exception)
11
{
12
    if ($exception instanceof \App\Exceptions\CustomException)  {
13
        return $exception->render($request);
14
    }
15
16
    return parent::render($request, $exception);
17
}
18
...
19
...

După cum puteți vedea, se verifică în primul rând tipul de excepție în metoda de randare. Dacă tipul unei excepții este \App\Exceptions\CustomException  apelăm metoda de randare a clasei respective.

Deci acum totul este la locul lui. Să continuăm și să creăm un fișier de control la app/Http/Controllers/ExceptionController.php astfel încât să putem testa clasa noastră particularizată de excepție.

1
<?php
2
namespace App\Http\Controllers;
3
4
use App\Http\Controllers\Controller;
5
6
class ExceptionController extends Controller
7
{
8
    public function index()
9
    {
10
        // something went wrong and you want to throw CustomException

11
        throw new \App\Exceptions\CustomException('Something Went Wrong.');
12
    }
13
}

Desigur, aveți nevoie pentru a adăuga o rută asociată în routes/web.php, după cum se vede în următorul fragment de cod.

1
// Exception routes

2
Route::get('exception/index', 'ExceptionController@index');

Având în vedere toate acestea, puteți accesa URL-ul http://your-laravel-site.com/exception/index pentru a vedea dacă functionează conform așteptărilor. Ar trebui să se afișeze view-ul errors.custom ca în configurația noastră.

Deci, acesta e modul în care ar trebui să vă ocupați de excepțiile particulare în Laravel. Și aici am ajuns la sfârșitul acestui articol — sper că v-ați bucurat de el!

Concluzie

Astăzi, am parcurs caracteristica de tratare a excepțiilor în Laravel. La începutul articolului am explorat configurația de bază oferită de Laravel pentru a randa și a raporta excepții. Mai mult, am aruncat o scurtă privire și la clasa implicită de tratare a excepției.

În a doua jumătate a articolului, am pregătit o clasă particularizată de tratare a excepțiilor care a demonstrat modul în care ați putea gestiona excepțiile particularizate din aplicație.

Pentru aceia dintre voi care doar ați început să lucrați cu Laravel sau sunteți în căutarea extinderii cunoștințele dvs., a site-ului sau a aplicației cu extensii, avem o varietate de lucruri pe care le puteți studia în Envato Market.

Mi-ar placea sa aud vești de la dvs, sub forma de intrebări și sugestii!

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.