PHP Framework: Einfach, schnell & ohne Composer

Logo für das phpFK - PHP Framework

Logo für das phpFK – PHP Framework

Das phpFK PHP Framework ist ein leichtgewichtiges, aber leistungsstarkes PHP-Framework
ohne Composer, das eine saubere MVC-Architektur, Sicherheitsfeatures
und optional ein Cache- & Upload-System bietet.

Viele Projekte können mit dem PHP Framework damit realisiert werden. Hier findest Du einen Überblick über die Struktur, Installation und wichtigste Features.

Unter Download kannst Du Dir das PHP Framework runterladen! Unter Hilfe findest Du Code Beispiele für das PHP Framework! Benötigst Du individuelle Hilfestellung zum PHP Framework, dann kontaktiere den Support! Außerdem kannst Du PHP lernen wir vermitteln Dir die PHP Grundlagen!

Projektstruktur

framework/
│
├── public/                         # Öffentlich zugängliche Dateien
│   ├── index.php                   # Front Controller
│   ├── .htaccess                   # URL-Rewrites & Sicherheit
│   ├── assets/
│       ├── bootstrap/              # (Leer, Bootstrap per CDN geladen)
│
├── app/                            # Anwendungslogik
│   ├── controllers/                # Controller (z. B. HomeController.php)
│   ├── models/                     # Datenbankmodelle
│   ├── views/                      # HTML-Templates (z. B. home.php)
│   ├── routes.php                  # Routenverwaltung
│   ├── languages/                  # Language-Dateien (z. B. de.php, en.php)
│
├── core/                           # Framework-Kern
│   ├── Autoloader.php              # Lädt alle Klassen automatisch
│   ├── Router.php                  # Routing-System
│   ├── Request.php                 # Verarbeitung von HTTP-Anfragen
│   ├── Response.php                # HTTP-Antworten
│   ├── Controller.php              # Basisklasse für Controller
│   ├── Model.php                   # Basisklasse für Modelle
│   ├── View.php                    # Template-Renderer
│   ├── Security.php                # Sicherheitsmechanismen (CSRF, XSS, SQL-Injection)
│   ├── Session.php                 # Session-Verwaltung
│   ├── Logger.php                  # Logging-System
│   ├── ErrorHandler.php            # Fehlerbehandlung
│   ├── Cache.php                   # Einfaches Datei-basiertes Cache-System
│   ├── Upload.php                  # Datei-Upload-Funktion
│   ├── Language.php                # Sprachlogik (Lade- und Setzfunktionen)
│
├── config/                         # Konfigurationsdateien
│   ├── app.php                     # Allgemeine App-Einstellungen
│   ├── database.php                # Datenbankkonfiguration
│   ├── security.php                # Sicherheitsoptionen
│   ├── cache.php                   # Cache-Konfiguration (Datei-basiert)
│   ├── upload.php                  # Upload-Konfiguration
│
├── storage/                        # Temporäre und persistente Daten
│   ├── logs/                       # Log-Dateien werden hier gespeichert
│   ├── cache/                      # Cache-Dateien
│   ├── uploads/                    # Hochgeladene Dateien
│
├── README.html                     # Dokumentation

Installation & Nutzung

  1. Projekt in den Webserver-Root legen (z. B. bei XAMPP 
    htdocs/
  2. Datenbank konfigurieren: Passe die Werte an (falls du eine DB nutzt) 
    config/database.php
  3. Starten des lokalen Servers:
php -S localhost:8000 -t public/

Zugriff auf die Anwendung: Besuche

http://localhost:8000

Features für das PHP Framework

  • Saubere MVC-Architektur
  • Routing-System mit Controller-Unterstützung
  • Autoloading für alle Core-Klassen
  • Einfache Datenbankabfragen mit PDO
  • Session- & Sicherheitsfunktionen (CSRF, XSS-Schutz, SQL-Injection-Schutz)
  • Logging & Fehlerbehandlung
  • Bootstrap-Support über CDN
  • Datei-basiertes Cache-System (optionale Nutzung)
  • Datei-Upload-Funktion (Upload-Klasse & Config)

Routenverwaltung (app/routes.php)

php
$router->addRoute('/', function() {
    echo "Willkommen!";
});

$router->addRoute('/home', [HomeController::class, 'index']);

Du kannst beliebig viele Routen definieren, um verschiedene Bereiche der Anwendung anzusteuern.
Für fortgeschrittene Anwendungen erstellst du eigene Controller in

app/controllers/

die komplexe Logik ausführen.

Sicherheitsmechanismen

  • CSRF-Schutz: Automatische Token-Generierung und -Prüfung
  • XSS-Schutz: 
    Security::sanitize($input)

    zum Filtern von Benutzereingaben

  • SQL-Injection-Schutz: Verwendung von 
    PDO::prepare()

    in

    Model.php

Fehlerbehandlung & Logging

  • Alle Fehler werden in 
    storage/logs/YYYY-MM-DD.log

    gespeichert

  • Benutzer sehen nur eine generische Fehlermeldung (500)

Cache-System für das PHP Framework

Das Framework enthält nun ein Datei-basiertes Cache-System

core/Cache.php

Konfiguration findest du in

config/cache.php
php
// Beispiel: Cache initialisieren (z. B. in public/index.php)
$cacheConfig = require CONFIG_PATH . 'cache.php';
\Core\Cache::init($cacheConfig);

// Wert in den Cache schreiben
\Core\Cache::put('mein_schluessel', 'Hallo Welt', 600);

// Wert aus dem Cache lesen
$value = \Core\Cache::get('mein_schluessel');
if ($value) {
    echo "Cache-Wert: " . $value;
}

Du kannst den Cache nutzen, musst aber nicht. Setze in

config/cache.php

‚ENABLED‘ => false,
um ihn komplett zu deaktivieren.

Upload-System

Das Framework enthält eine Upload-Klasse (

core/Upload.php

) für Datei-Uploads.

Die Einstellungen (erlaubte Dateitypen, maximale Größe) findest du in 

config/upload.php

:

// Beispiel: Route zum Hochladen (app/routes.php)
$router->addRoute('/upload', function() {
    if ($_SERVER['REQUEST_METHOD'] === 'POST') {
        $uploadConfig = require CONFIG_PATH . 'upload.php';
        $uploader     = new \Core\Upload($uploadConfig);
        $result       = $uploader->uploadFile('userfile');

        if ($result['success']) {
            echo 'Upload erfolgreich! Gespeichert unter: ' . $result['path'];
        } else {
            echo 'Fehler: ' . $result['error'];
        }
    } else {
        // Formular anzeigen
        echo '<form enctype="multipart/form-data" method="POST">';
        echo '<input type="file" name="userfile" />';
        echo '<button type="submit">Hochladen</button>';
        echo '</form>';
    }
});

Wenn du das Formular statisch im Template nutzen möchtest:

<form enctype="multipart/form-data" method="POST">
  <input type="file" name="userfile" />
  <button type="submit">Hochladen</button>
</form>

Rufe diese Route z. B. mit

http://localhost/phpframework/public/upload

auf,
wähle eine Datei aus und drücke Hochladen.
Die Datei landet in

storage/uploads/

Einstieg in das PHP Framework

Hier ein kurzer Überblick, wie du mit dem phpFK PHP Framework arbeitest:

  1. Installation – Kopiere das Projekt in deinen Webserver. Stelle sicher, dass 
    storage/

    beschreibbar ist.

  2. Konfiguration – Passe 
    config/app.php

    ,

    config/database.php

    ,

    config/cache.php

    etc. an deine Bedürfnisse an.

  3. Routen definieren – In 
    app/routes.php

    kannst du

    $router->addRoute()

    aufrufen. Verweise entweder direkt auf eine Callback-Funktion oder gib einen Controller & eine Methode an. Beispiel:

    $router->addRoute('/profile', [ProfileController::class, 'show']);
  4. Controller erstellen – Leg eine Datei 
    app/controllers/ProfileController.php

    an. Erbt von

    Core\Controller

    . Nutze

    $this->view('profile')

    oder

    \Core\View::render()

    , um Templates zu laden.

  5. Cache nutzen – Falls gewünscht, initialisiere den Cache in 
    public/index.php

    ( z. B.

    \Core\Cache::init()

    ). Cache-Aufrufe mit

    Cache::put()

    und

    Cache::get()

    für schnelle Performance.

  6. Uploads – Baue ein Formular, nutze 
    \Core\Upload

    , definiere Regeln in

    config/upload.php

    . Dateien liegen nach dem Upload in

    storage/uploads/

    .

  7. Sicherheit – Nutze 
    Security::sanitize()

    für Benutzereingaben, CSRF-Tokens in Formularen und PDO-Prepared-Statements in

    Model.php

    .

  8. Fehler & Logs – Sieh in 
    storage/logs/

    nach. Bei Fehlern wird dort ein Eintrag erstellt.

  9. Deployment – Auf dem Live-Server sollte 
    .htaccess

    RewriteEngine On haben, AllowOverride All aktiv sein. Schalte

    display_errors

    ab (Produktionsumgebung).

Tipp: Das Framework ist flexibel: Du kannst Cache & Upload bei Bedarf nutzen oder einfach deaktivieren. Die Kernkomponenten (Routing, Controller, View) bleiben davon unberührt.

Weiterentwicklung

  • Erweiterbar mit Middleware (z. B. für Authentifizierung, Rate-Limiting)
  • Möglichkeit zur Template-Engine-Integration (Blade, Twig etc.)
  • API-Unterstützung mit JSON-Response-System
  • Einbindung anderer Datenbanken (PostgreSQL, SQLite) durch PDO

Language Pack (Mehrsprachige Ausgabe)

Um das Framework mehrsprachig zu machen, kannst du ein Language Pack einbinden.
Lege dazu unter

app/languages/

verschiedene Sprachdateien an, z. B.:

app/
└── languages/
    ├── de.php
    ├── en.php
    └── es.php

Jede Datei gibt ein PHP-Array zurück, das die Übersetzungen enthält, z.B.:

php
// app/languages/de.php
return [
  'welcome_message' => 'Willkommen im phpFK PHP Framework!',
  'button_save' => 'Speichern',
  // ... weitere Schlüssel
];

Im englischen Pendant (en.php):

php
return [
  'welcome_message' => 'Welcome to the phpFK PHP Framework!',
  'button_save' => 'Save',
];

Dann erstellst du unter

core/Language.php

eine Klasse, die die Sprachdatei lädt und den gewünschten Text zurückgibt:

php
namespace Core;

class Language {
  private static $lang = 'de';
  private static $translations = [];

  public static function setLanguage($lang)
  {
    $file = APP_PATH . 'languages/' . $lang . '.php';
    if (file_exists($file)) {
      self::$lang = $lang;
      self::$translations = include $file;
    } else {
      // Fallback
      $fallback = APP_PATH . 'languages/' . self::$lang . '.php';
      if (file_exists($fallback)) {
        self::$translations = include $fallback;
      } else {
        self::$translations = [];
      }
    }
  }

  public static function get($key)
  {
    return self::$translations[$key] ?? "LANG_KEY_NOT_FOUND: $key";
  }
}

In deinem Code (z. B. in

public/index.php

) wählst du eine Sprache:

php
\Core\Language::setLanguage('de');
echo \Core\Language::get('welcome_message');

So erhältst du je nach eingestellter Sprache den passenden Text.
Möchtest du per URL zwischen Sprachen umschalten, fügst du z. B.

?lang=en

hinzu und rufst

Language::setLanguage($_GET['lang'])

auf.

Lizenz

Das phpFK PHP Framework kann für einmalig 50,00 € Netto zuzüglich 19 Prozent Umsatzsteuer erworben werden und dann uneingeschränkt verwendet werden.