Help me een aangepaste foutafhandelingsmechanisme implementeren in mijn CodeIgniter-project.
description
Het implementeren van een aangepast foutafhandelingsmechanisme kan leiden tot een verbeterde gebruikerservaring door duidelijke foutmeldingen te bieden, betere debuggingmogelijkheden en een hogere betrouwbaarheid van de toepassing.
prompt
try_prompt
Guideer me over hoe ik een aangepast foutafhandelingsmechanisme kan maken in mijn CodeIgniter-toepassing. Beschrijf hoe je verschillende soorten fouten kunt vastleggen, ze effect ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een stapsgewijze gids om een aangepast foutafhandelingsmechanisme te implementeren in je CodeIgniter 4.1.5 toepassing, inclusief het vastleggen van verschillende fouten, het loggen ervan en het tonen van gebruiksvriendelijke meldingen. We richten ons specifiek op het afhandelen van databaseverbinding fouten.
1. **Gebruik van Exceptions en Custom Error Handler**
CodeIgniter 4 biedt een ingebouwd exception- en foutafhandelingssysteem. Je kunt een custom exception handler maken door de `app/Config/Exceptions.php` aan te passen of door een middleware te implementeren.
---
2. **Databaseverbinding fout detecteren en afhandelen**
Wanneer je probeert verbinding te maken met de database, kun je exceptions vangen en deze op een aangepaste manier afhandelen.
Voorbeeld:
```php
// In je controller of model
use CodeIgniter\Database\Exceptions\DatabaseException;
try {
// Bijvoorbeeld, initialiseer database verbinding
$db = \Config\Database::connect();
// Probeer een eenvoudige query uit te voeren
$db->query("SELECT 1");
} catch (DatabaseException $e) {
// Log de fout
log_message('error', 'Database connectie fout: ' . $e->getMessage());
// Toon een gebruiksvriendelijke foutmelding
return view('errors/database_error');
}
```
---
3. **Aanpassen van de foutpagina**
Maak een view `app/Views/errors/database_error.php` met bijvoorbeeld:
```php
<h1>Databaseverbinding mislukt</h1>
<p>We kunnen momenteel geen verbinding maken met de database. Probeer het later opnieuw.</p>
```
---
4. **Globale foutafhandeling en logging**
Je kunt ook de `app/Config/Exceptions.php` aanpassen om onvoorziene fouten te verwerken en te loggen.
Voorbeeld:
```php
public static function forPHPError($severity, $message, $filepath, $line, $trace = [])
{
log_message('error', "PHP error: {$message} in {$filepath} op regel {$line}");
// Eventueel aangepaste handling
return parent::forPHPError($severity, $message, $filepath, $line, $trace);
}
```
---
5. **Gebruik van Middleware voor globale foutafhandeling**
Je kunt ook een middleware maken die alle fouten afvangt, bijvoorbeeld in `app/Filters/` en deze gebruiken om fouten te loggen en gebruikersvriendelijke meldingen te tonen.
---
6. **Samenvatting van beste praktijken**
- Vang specifieke fouten zoals `DatabaseException` in je code en behandel ze apart.
- Log fouten altijd met `log_message()` voor later onderzoek.
- Toon gebruikersvriendelijke meldingen via aangepaste views.
- Overweeg het gebruik van een globale foutpagina voor onvoorziene fouten.
- Test je foutafhandeling door je database uit te schakelen of te vervalsen.
---
**Kortom:**
- Gebruik try-catch blokken rond databaseverbindingen.
- Log fouten met `log_message()`.
- Maak aangepaste foutpagina’s voor een vriendelijke gebruikerservaring.
- Pas eventueel `Exceptions.php` aan voor algemene foutafhandeling.
Als je meer hulp nodig hebt bij een specifiek onderdeel, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Hier is een uitgebreide handleiding voor het maken van een aangepast foutafhandelingsmechanisme in CodeIgniter 4.1.5:
## 1. Basis Foutafhandeling Configureren
### app/Config/Boot/development.php & production.php
```php
// In development.php
error_reporting(E_ALL);
ini_set('display_errors', '1');
// In production.php
error_reporting(E_ALL & ~E_DEPRECATED & ~E_STRICT);
ini_set('display_errors', '0');
```
## 2. Aangepaste Exception Handler Maken
### app/Config/Exceptions.php
```php
<?php
namespace Config;
use CodeIgniter\Config\BaseConfig;
use CodeIgniter\Debug\ExceptionHandler;
use CodeIgniter\HTTP\ResponseInterface;
use Throwable;
class Exceptions extends BaseConfig
{
public function __construct()
{
parent::__construct();
// Vervang de standaard exception handler
set_exception_handler([$this, 'customExceptionHandler']);
}
public function customExceptionHandler(Throwable $exception)
{
$this->logException($exception);
$this->displayCustomError($exception);
}
private function logException(Throwable $exception)
{
$logMessage = sprintf(
"Fout: %s in %s op regel %s\nStack trace:\n%s",
$exception->getMessage(),
$exception->getFile(),
$exception->getLine(),
$exception->getTraceAsString()
);
log_message('error', $logMessage);
}
private function displayCustomError(Throwable $exception)
{
$response = service('response');
if (ENVIRONMENT === 'production') {
$view = view('errors/custom_error', [
'message' => 'Er is een fout opgetreden. Onze technici zijn op de hoogte gesteld.',
'code' => $exception->getCode()
]);
$response->setStatusCode(500)
->setBody($view)
->send();
} else {
// Toon gedetailleerde fout in development
$view = view('errors/debug_error', [
'exception' => $exception
]);
$response->setStatusCode(500)
->setBody($view)
->send();
}
exit(1);
}
}
```
## 3. Database Fout Specifieke Handler
### app/Controllers/BaseController.php
```php
<?php
namespace App\Controllers;
use CodeIgniter\Controller;
use CodeIgniter\Database\Exceptions\DatabaseException;
use CodeIgniter\HTTP\ResponseInterface;
class BaseController extends Controller
{
protected function handleDatabaseError(DatabaseException $e)
{
$errorNumber = $e->getCode();
// Specifieke database fouten afhandelen
switch ($errorNumber) {
case 2002: // Connection timeout
case 1045: // Access denied
$userMessage = 'Kan geen verbinding maken met de database. Probeer het later opnieuw.';
$logLevel = 'critical';
break;
case 1049: // Unknown database
$userMessage = 'Database configuratie fout. Neem contact op met de beheerder.';
$logLevel = 'alert';
break;
case 2006: // MySQL server has gone away
$userMessage = 'Database verbinding verbroken. Probeer het opnieuw.';
$logLevel = 'error';
break;
default:
$userMessage = 'Er is een database fout opgetreden.';
$logLevel = 'error';
}
// Log de fout met extra context
$this->logDatabaseError($e, $logLevel);
// Toon gebruiksvriendelijke foutmelding
return $this->showDatabaseError($userMessage, $errorNumber);
}
private function logDatabaseError(DatabaseException $e, string $level)
{
$context = [
'error_code' => $e->getCode(),
'error_message' => $e->getMessage(),
'sql_query' => method_exists($e, 'getQuery') ? $e->getQuery() : 'N/A',
'backtrace' => $e->getTraceAsString()
];
log_message($level, 'Database fout: ' . $e->getMessage(), $context);
}
private function showDatabaseError(string $message, int $errorCode)
{
$data = [
'title' => 'Database Fout',
'message' => $message,
'errorCode' => $errorCode
];
return view('errors/database_error', $data);
}
}
```
## 4. Database Connection Monitoring
### app/Models/DatabaseMonitor.php
```php
<?php
namespace App\Models;
use CodeIgniter\Model;
use CodeIgniter\Database\BaseConnection;
class DatabaseMonitor extends Model
{
protected $db;
public function __construct()
{
$this->db = db_connect();
}
public function checkConnection(): bool
{
try {
return $this->db->query('SELECT 1')->getResult() !== null;
} catch (\Exception $e) {
log_message('error', 'Database verbinding controle mislukt: ' . $e->getMessage());
return false;
}
}
public function getConnectionStats(): array
{
try {
$stats = [
'connected' => $this->checkConnection(),
'last_check' => date('Y-m-d H:i:s')
];
return $stats;
} catch (\Exception $e) {
return ['connected' => false, 'error' => $e->getMessage()];
}
}
}
```
## 5. Error Views Maken
### app/Views/errors/database_error.php
```html
<!DOCTYPE html>
<html>
<head>
<title><?= esc($title) ?></title>
<style>
.error-container {
max-width: 600px;
margin: 50px auto;
padding: 20px;
border: 1px solid #e0e0e0;
border-radius: 5px;
text-align: center;
}
.error-code {
font-size: 48px;
color: #dc3545;
}
.error-message {
font-size: 18px;
margin: 20px 0;
}
</style>
</head>
<body>
<div class="error-container">
<div class="error-code">Database Fout</div>
<div class="error-message"><?= esc($message) ?></div>
<?php if (ENVIRONMENT !== 'production'): ?>
<div class="debug-info">
Foutcode: <?= esc($errorCode) ?>
</div>
<?php endif; ?>
<p>Onze technici zijn op de hoogte gesteld van dit probleem.</p>
<a href="/">Terug naar homepagina</a>
</div>
</body>
</html>
```
## 6. Gebruik in Controllers
### app/Controllers/ExampleController.php
```php
<?php
namespace App\Controllers;
use CodeIgniter\Database\Exceptions\DatabaseException;
class ExampleController extends BaseController
{
public function getUserData($userId)
{
try {
$db = db_connect();
$query = $db->query("SELECT * FROM users WHERE id = ?", [$userId]);
$user = $query->getRow();
if (!$user) {
throw new \Exception('Gebruiker niet gevonden');
}
return $this->response->setJSON($user);
} catch (DatabaseException $e) {
// Database-specifieke fouten
return $this->handleDatabaseError($e);
} catch (\Exception $e) {
// Algemene fouten
log_message('error', 'Algemene fout: ' . $e->getMessage());
return $this->response->setStatusCode(500)
->setJSON(['error' => 'Er is een fout opgetreden']);
}
}
}
```
## 7. Configuratie voor Logging
### app/Config/Logger.php
```php
public $threshold = 4; // Log alles: 0=uit, 1=errors, 2=debug, 3=info, 4=alle
public $handlers = [
'CodeIgniter\Log\Handlers\FileHandler' => [
'handles' => ['critical', 'alert', 'error', 'warning', 'notice', 'info', 'debug'],
'fileExtension' => '',
'filePermissions' => 0644,
'path' => WRITEPATH . 'logs/',
]
];
```
## Belangrijke punten:
1. **Omgeving afhankelijk**: Toon verschillende foutniveaus voor development vs production
2. **Veiligheid**: Gebruik altijd `esc()` voor output in views
3. **Logging**: Log voldoende context voor debugging
4. **Gebruikerservaring**: Toon duidelijke, niet-technische foutmeldingen
5. **Monitoring**: Implementeer database health checks voor proactieve monitoring
Deze implementatie zorgt voor robuuste foutafhandeling met specifieke aandacht voor databaseverbindingsfouten in je CodeIgniter 4.1.5 applicatie.