Cache- und Upload-Funktion

Erste Schritte: Cache- und Upload-Funktion

Das phpFK – PHP Framework bietet optionale Module für
einen einfachen, datei-basierten Cache und für Datei-Uploads.
In diesem Tutorial lernst du, wann sich das Caching lohnt
und wie du Dateien sicher hochladen kannst.

Datei-basiertes Caching einschalten

Ein Cache-System kann gerade bei aufwendigen Datenbankabfragen
oder API-Aufrufen die Performance deiner Anwendung spürbar steigern.
Statt bei jedem Seitenaufruf erneut alle Prozesse auszuführen,
schreibst du die Ergebnisse in eine Cache-Datei
und lädst sie wieder ein, solange sie noch gültig (nicht abgelaufen) ist.

Konfiguration: config/cache.php

Im Ordner config/ findest du typischerweise
eine Datei cache.php, in der du Einstellungen
zum Cache-System vornehmen kannst: 

return [
    'ENABLED' => true,
    'PATH'    => STORAGE_PATH . 'cache/',
    'TTL'     => 600 // Zeit in Sekunden (z. B. 10 Minuten)
];

– ENABLED: Schaltet das Caching ein oder aus.
– PATH: Ordner, in dem Cache-Dateien gespeichert werden.
– TTL: „Time To Live“, also wie lange (in Sekunden)
ein Cache-Eintrag gültig sein soll.

Cache verwenden

Steht das Caching auf ENABLED = true, kannst du
in public/index.php oder in deinem Controller
den Cache initialisieren und verwenden. Ein vereinfachtes Beispiel: 

use Core\Cache;

$cacheConfig = require CONFIG_PATH . 'cache.php';
Cache::init($cacheConfig);

// Wert in den Cache speichern
Cache::put('meinschluessel', 'Hallo Welt!', 300);

// Wert wieder aus dem Cache lesen
$data = Cache::get('meinschluessel');
if ($data !== null) {
    echo "Gecachte Daten: " . $data;
} else {
    echo "Wert nicht gefunden oder abgelaufen.";
}

1. Cache::init liest deine Cache-Konfiguration ein.
2. Cache::put legt den Wert „Hallo Welt!“ unter
dem Schlüssel meinschluessel für max. 300 Sekunden ab.
3. Cache::get gibt entweder den gespeicherten Wert zurück
oder null, wenn er nicht existiert oder abgelaufen ist.

Tipps zum Caching

  • Wähle sinnvolle TTL-Werte: Nicht zu kurz, damit Caching überhaupt
    Effekt bringt, aber auch nicht zu lang, damit deine User keine
    veralteten Daten sehen.
  • Dateirechte checken: Der Ordner storage/cache/
    braucht Schreibrechte für deinen Webserver.
  • Cache löschen: Beim Entwickeln kann es Sinn machen,
    ab und zu den Cache-Ordner manuell zu leeren,
    falls du neue Änderungen nicht siehst.
  • Prüfe alternative Treiber: Bei sehr hohem Traffic
    oder größeren Datenmengen könnte ein In-Memory-Cache
    wie Redis oder Memcached sinnvoll sein.

Datei-Upload-Funktion

Das phpFK – PHP Framework enthält außerdem eine einfache
Upload-Klasse, die dir den Upload von Dateien (z. B. Bildern, PDFs)
erleichtert. Über config/upload.php lässt sich
steuern, welche Dateitypen erlaubt sind und wo sie abgespeichert werden.

Konfiguration: config/upload.php

So könntest du deine Upload-Einstellungen definieren: 

return [
    'UPLOAD_PATH' => STORAGE_PATH . 'uploads/',
    'ALLOWED_TYPES' => ['image/jpeg', 'image/png', 'application/pdf'],
    'MAX_SIZE' => 2 * 1024 * 1024 // 2 MB
];

– UPLOAD_PATH: Zielordner für hochgeladene Dateien
– ALLOWED_TYPES: Liste erlaubter MIME-Typen (Sicherheitsmaßnahme)
– MAX_SIZE: Maximal erlaubte Dateigröße in Bytes

Upload im Controller

Ein einfaches Beispiel, wie du in einer Route auf den Upload reagieren kannst: 

// app/controllers/UploadController.php

namespace App\Controllers;

use Core\Controller;
use Core\Upload;

class UploadController extends Controller
{
    public function form()
    {
        // Einfaches Formular, das die Datei an dieselbe Route per POST sendet
        // Darum hier einfach mit "echo" und HTML:
        echo <<<HTML
        <form method="POST" enctype="multipart/form-data">
            <input type="file" name="userfile" />
            <button type="submit">Hochladen</button>
        </form>
        HTML;
    }

    public function handle()
    {
        // Lies die Upload-Konfiguration
        $config = require CONFIG_PATH . 'upload.php';

        $uploader = new Upload($config);
        $result = $uploader->uploadFile('userfile');

        if ($result['success']) {
            echo "Upload erfolgreich! Gespeichert unter: " . $result['path'];
        } else {
            echo "Fehler: " . $result['error'];
        }
    }
}

Hier haben wir:

  • form() zeigt ein einfaches HTML-Formular für den Datei-Upload.
  • handle() nimmt die hochgeladene Datei entgegen,
    ruft uploadFile(‚userfile‘) auf und gibt eine Erfolgsmeldung
    oder Fehlermeldung aus.

Routes definieren

Damit deine Anwendung weiß, wie sie auf /upload oder /upload/handle reagiert,
legst du in app/routes.php fest: 

// app/routes.php
$router->addRoute('/upload', [\App\Controllers\UploadController::class, 'form']);
$router->addRoute('/upload/handle', [\App\Controllers\UploadController::class, 'handle']);

Sicherheit beim Upload

1. Prüfe Dateitypen und Größe: Die Upload-Klasse
nimmt nur Dateien an, deren MIME-Type in ALLOWED_TYPES eingetragen ist
und die MAX_SIZE nicht überschreitet.
2. Setze korrekte Zugriffsrechte: Der Ordner storage/uploads/
sollte für den Webserver beschreibbar, aber nicht für die Öffentlichkeit erreichbar sein,
wenn du vertrauliche Daten hochlädst.
3. Vermeide ausnutzbare Scripts: Gewähre hochgeladenen Dateien
niemals direkte Ausführungsrechte, um PHP-Shells oder ähnliche Exploits zu verhindern.
Eine passende .htaccess-Datei (Deny all) in uploads/ kann helfen.

Fazit

Das phpFK – PHP Framework macht es dir sehr leicht,
Caching und Datei-Uploads zu integrieren.
Mit ein paar Zeilen Code kannst du wertvolle Zeit beim
Datenbank- oder API-Zugriff sparen und flexibel Dateien
ins storage/uploads-Verzeichnis hochladen.
Achte beim Cachen auf sinnvolle TTL-Werte
und sichere deinen Upload-Ordner bestmöglich ab.
So kombiniert dein Projekt reibungslose Performance
mit einer bequemen Benutzererfahrung für Dateiuploads.