Help me een functie schakelaar systeem implementeren in mijn Laravel applicatie om de zichtbaarheid van nieuwe functies te controleren.
description
Het implementeren van een functie schakelaar systeem stelt je in staat nieuwe functies te testen met een subset van gebruikers, de risico's van deployment te verminderen en een betere gebruikerservaring te bieden door de zichtbaarheid van functies te controleren op basis van gebruikersfeedback of zakelijke behoeften.
prompt
try_prompt
Ik wil een functie schakelaar systeem maken in mijn Laravel applicatie dat me toestaat functies dynamisch in of uit te schakelen zonder nieuwe code te deployen. Leg uit hoe je dit systeem opzet, inclusief hoe je functievlaggen opsla ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Om een dynamisch functiezwaartesysteem in Laravel te maken waarmee je functies in of uit kunt schakelen zonder codewijzigingen, kun je de volgende aanpak volgen:
1. **Opslag van functievlaggen en status**
- Maak een database tabel, bijvoorbeeld `feature_flags`, met kolommen zoals:
- `id`
- `name` (bijvoorbeeld 'nieuw_dashboard')
- `is_active` (boolean)
- `created_at`
- `updated_at`
- Voer een migratie uit om deze tabel aan te maken:
```php
Schema::create('feature_flags', function (Blueprint $table) {
$table->id();
$table->string('name')->unique();
$table->boolean('is_active')->default(false);
$table->timestamps();
});
```
- Vul eventueel initiële functies in via seeder of via het beheerderspanel.
2. **Model en Accessor**
- Maak een Eloquent model `FeatureFlag`:
```php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class FeatureFlag extends Model
{
protected $fillable = ['name', 'is_active'];
}
```
- Overweeg een helper of service class om de status eenvoudig op te vragen:
```php
namespace App\Services;
use App\Models\FeatureFlag;
class FeatureFlagService
{
public static function isActive(string $name): bool
{
return FeatureFlag::where('name', $name)->value('is_active') ?? false;
}
}
```
3. **Beheerdersinterface**
- Maak een eenvoudige CRUD-bewerkingspagina voor `FeatureFlag`-records:
- Gebruik Laravel Breeze, Laravel Nova, of een custom admin panel.
- Zorg dat je in de interface de naam en status kunt aanpassen.
- Bij het opslaan wordt de `is_active`-status bijgewerkt zonder codewijziging.
4. **Gebruik in de applicatie**
- Controleer de status van een functie voor gebruik:
```php
use App\Services\FeatureFlagService;
if (FeatureFlagService::isActive('nieuw_dashboard')) {
// Toon de nieuwe dashboardfunctionaliteit
} else {
// Toon de oude dashboard
}
```
- Voor routebeschikbaarheid kun je middleware maken:
```php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use App\Services\FeatureFlagService;
class CheckFeatureFlag
{
public function handle(Request $request, Closure $next, $flag)
{
if (!FeatureFlagService::isActive($flag)) {
// Optioneel: redirect of 404
abort(404);
}
return $next($request);
}
}
```
- Registreer de middleware in `app/Http/Kernel.php`, bijvoorbeeld:
```php
protected $routeMiddleware = [
// ...
'feature' => \App\Http\Middleware\CheckFeatureFlag::class,
];
```
- Gebruik het in routes:
```php
Route::get('/nieuw-dashboard', function () {
// Nieuwe dashboard view
})->middleware('feature:nieuw_dashboard');
```
**Samenvatting:**
- Sla functiezwaartes op in een database tabel.
- Beheer ze via een admininterface.
- Controleer via een service of middleware of een functie actief is.
- Pas de functionaliteit of routes aan op basis van deze flags.
Zo creëer je een flexibel, dynamisch systeem voor het in- en uitschakelen van functies zonder code-deployment.
provider: deepseek
model: deepseek-chat
Hier is een complete uitleg voor het opzetten van een functieschakelaar systeem in Laravel:
## 1. Database Setup
Maak eerst een migratie voor de functievlaggen:
```bash
php artisan make:migration create_feature_flags_table
```
```php
// database/migrations/xxxx_xx_xx_xxxxxx_create_feature_flags_table.php
public function up()
{
Schema::create('feature_flags', function (Blueprint $table) {
$table->id();
$table->string('name')->unique();
$table->boolean('is_enabled')->default(false);
$table->text('description')->nullable();
$table->timestamps();
});
}
```
## 2. Model Aanmaken
```bash
php artisan make:model FeatureFlag
```
```php
// app/Models/FeatureFlag.php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class FeatureFlag extends Model
{
protected $fillable = ['name', 'is_enabled', 'description'];
protected $casts = [
'is_enabled' => 'boolean',
];
}
```
## 3. Service Class voor Feature Flags
```bash
php artisan make:class Services/FeatureFlagService
```
```php
// app/Services/FeatureFlagService.php
namespace App\Services;
use App\Models\FeatureFlag;
use Illuminate\Support\Facades\Cache;
class FeatureFlagService
{
protected $cacheKey = 'feature_flags';
protected $cacheTtl = 3600; // 1 uur
public function isEnabled(string $featureName): bool
{
return Cache::remember(
"{$this->cacheKey}.{$featureName}",
$this->cacheTtl,
fn() => FeatureFlag::where('name', $featureName)->value('is_enabled') ?? false
);
}
public function enable(string $featureName): void
{
$this->updateFlag($featureName, true);
}
public function disable(string $featureName): void
{
$this->updateFlag($featureName, false);
}
protected function updateFlag(string $featureName, bool $enabled): void
{
FeatureFlag::updateOrCreate(
['name' => $featureName],
['is_enabled' => $enabled]
);
Cache::forget("{$this->cacheKey}.{$featureName}");
}
public function getAllFlags()
{
return Cache::remember($this->cacheKey, $this->cacheTtl, function () {
return FeatureFlag::all()->keyBy('name');
});
}
}
```
## 4. Middleware voor Route Bescherming
```bash
php artisan make:middleware FeatureFlagMiddleware
```
```php
// app/Http/Middleware/FeatureFlagMiddleware.php
namespace App\Http\Middleware;
use App\Services\FeatureFlagService;
use Closure;
use Illuminate\Http\Request;
class FeatureFlagMiddleware
{
public function __construct(protected FeatureFlagService $featureFlagService)
{
}
public function handle(Request $request, Closure $next, string $featureName)
{
if (!$this->featureFlagService->isEnabled($featureName)) {
abort(404, 'Deze functie is momenteel niet beschikbaar.');
}
return $next($request);
}
}
```
Registreer de middleware in `app/Http/Kernel.php`:
```php
protected $routeMiddleware = [
// ... bestaande middleware
'feature' => \App\Http\Middleware\FeatureFlagMiddleware::class,
];
```
## 5. Beheerdersinterface
### Controller
```bash
php artisan make:controller Admin/FeatureFlagController
```
```php
// app/Http/Controllers/Admin/FeatureFlagController.php
namespace App\Http\Controllers\Admin;
use App\Http\Controllers\Controller;
use App\Models\FeatureFlag;
use App\Services\FeatureFlagService;
use Illuminate\Http\Request;
class FeatureFlagController extends Controller
{
public function __construct(protected FeatureFlagService $featureFlagService)
{
}
public function index()
{
$flags = $this->featureFlagService->getAllFlags();
return view('admin.feature-flags.index', compact('flags'));
}
public function update(Request $request, FeatureFlag $featureFlag)
{
$validated = $request->validate([
'is_enabled' => 'required|boolean'
]);
if ($validated['is_enabled']) {
$this->featureFlagService->enable($featureFlag->name);
} else {
$this->featureFlagService->disable($featureFlag->name);
}
return redirect()->back()->with('success', 'Functievlag bijgewerkt!');
}
public function create()
{
return view('admin.feature-flags.create');
}
public function store(Request $request)
{
$validated = $request->validate([
'name' => 'required|string|unique:feature_flags,name',
'description' => 'nullable|string',
'is_enabled' => 'boolean'
]);
FeatureFlag::create($validated);
return redirect()->route('admin.feature-flags.index')
->with('success', 'Nieuwe functievlag aangemaakt!');
}
}
```
### Views
```blade
{{-- resources/views/admin/feature-flags/index.blade.php --}}
@extends('layouts.admin')
@section('content')
<div class="container">
<h1>Functie Schakelaars</h1>
<a href="{{ route('admin.feature-flags.create') }}" class="btn btn-primary mb-3">
Nieuwe Functievlag
</a>
<div class="card">
<div class="card-body">
<table class="table">
<thead>
<tr>
<th>Naam</th>
<th>Beschrijving</th>
<th>Status</th>
<th>Acties</th>
</tr>
</thead>
<tbody>
@foreach($flags as $flag)
<tr>
<td>{{ $flag->name }}</td>
<td>{{ $flag->description }}</td>
<td>
<span class="badge {{ $flag->is_enabled ? 'bg-success' : 'bg-danger' }}">
{{ $flag->is_enabled ? 'Ingeschakeld' : 'Uitgeschakeld' }}
</span>
</td>
<td>
<form action="{{ route('admin.feature-flags.update', $flag) }}" method="POST">
@csrf
@method('PUT')
<input type="hidden" name="is_enabled" value="{{ $flag->is_enabled ? 0 : 1 }}">
<button type="submit" class="btn btn-sm {{ $flag->is_enabled ? 'btn-warning' : 'btn-success' }}">
{{ $flag->is_enabled ? 'Uitschakelen' : 'Inschakelen' }}
</button>
</form>
</td>
</tr>
@endforeach
</tbody>
</table>
</div>
</div>
</div>
@endsection
```
## 6. Routes
```php
// routes/web.php
// Beheer routes
Route::prefix('admin')->middleware(['auth', 'admin'])->group(function () {
Route::get('/feature-flags', [FeatureFlagController::class, 'index'])->name('admin.feature-flags.index');
Route::get('/feature-flags/create', [FeatureFlagController::class, 'create'])->name('admin.feature-flags.create');
Route::post('/feature-flags', [FeatureFlagController::class, 'store'])->name('admin.feature-flags.store');
Route::put('/feature-flags/{featureFlag}', [FeatureFlagController::class, 'update'])->name('admin.feature-flags.update');
});
// Gebruik voorbeeld: nieuw_dashboard
Route::get('/dashboard', function () {
return view('dashboard.old');
})->name('dashboard');
Route::get('/nieuw-dashboard', function () {
return view('dashboard.new');
})->name('nieuw-dashboard')->middleware('feature:nieuw_dashboard');
```
## 7. Service Provider (Optioneel)
```php
// app/Providers/AppServiceProvider.php
public function register()
{
$this->app->singleton(FeatureFlagService::class, function ($app) {
return new FeatureFlagService();
});
}
```
## 8. Gebruik in Controllers en Views
### In Controllers:
```php
public function showDashboard()
{
$featureFlagService = app(FeatureFlagService::class);
if ($featureFlagService->isEnabled('nieuw_dashboard')) {
return view('dashboard.new');
}
return view('dashboard.old');
}
```
### In Views:
```blade
@if(app(\App\Services\FeatureFlagService::class)->isEnabled('nieuw_dashboard'))
<a href="{{ route('nieuw-dashboard') }}" class="btn btn-primary">
Naar Nieuw Dashboard
</a>
@endif
```
### In Blade Directives (Optioneel):
```php
// AppServiceProvider boot method
Blade::if('feature', function ($feature) {
return app(FeatureFlagService::class)->isEnabled($feature);
});
```
```blade
@feature('nieuw_dashboard')
<!-- Toon nieuwe functionaliteit -->
<div class="new-feature">
Nieuwe dashboard content
</div>
@endfeature
```
## 9. Seeder voor Initiële Data
```bash
php artisan make:seeder FeatureFlagSeeder
```
```php
// database/seeders/FeatureFlagSeeder.php
public function run()
{
FeatureFlag::create([
'name' => 'nieuw_dashboard',
'is_enabled' => false,
'description' => 'Het nieuwe dashboard design en functionaliteiten'
]);
}
```
Dit systeem biedt je een robuuste manier om functies dynamisch in en uit te schakelen zonder nieuwe deployments. De cache-laag zorgt voor goede prestaties en de beheerdersinterface maakt het eenvoudig om flags te beheren.