Der Begriff CRUD ist eng mit dem Ma­nage­ment digitaler Daten verknüpft. Genauer gesagt handelt es sich bei CRUD um ein Akronym, das sich aus den Be­zeich­nun­gen für die vier fun­da­men­ta­len Ope­ra­tio­nen per­sis­ten­ter Datenbank-An­wen­dun­gen ableiten lässt:

  • Create (Datensatz anlegen)
  • Read bzw. Retrieve (Datensatz lesen)
  • Update (Datensatz ak­tua­li­sie­ren)
  • Delete bzw. Destroy (Datensatz löschen)

Ver­ein­facht gesagt fasst der Begriff CRUD die Funk­tio­nen zusammen, die ein Nutzer benötigt, um Daten anzulegen und zu verwalten. Diverse Da­ten­ver­wal­tungs­pro­zes­se basieren auf CRUD, wobei die Ope­ra­tio­nen spe­zi­fisch an die An­for­de­run­gen von System und User angepasst sind – egal, ob bei der Ver­wal­tung von Da­ten­ban­ken oder bei der Nutzung von An­wen­dun­gen. So sind Ope­ra­tio­nen die typischen und un­ver­zicht­ba­ren Zu­griffs­werk­zeu­ge mit denen Experten bei­spiels­wei­se Da­ten­bank­pro­ble­me über­prü­fen können, während CRUD für einen User bedeutet, einen Account anlegen (create) und jederzeit nutzen (read), anpassen (update) oder löschen (delete) zu können. Abhängig von der Sprach­um­ge­bung werden die CRUD-Ope­ra­tio­nen außerdem ganz un­ter­schied­lich aus­ge­führt, wie die folgende Tabelle zeigt:

CRUD-Operation SQL RESTful HTTP XQuery
Create INSERT POST, PUT insert
Read SELECT GET, HEAD copy/modify/return
Update UPDATE PUT, PATCH replace, rename
Delete DELETE DELETE delete
KI-Assistent kostenlos – Ihr smarter All­tags­hel­fer
  • DSGVO-konform & sicher gehostet in Deutsch­land
  • Pro­duk­ti­vi­tät steigern – weniger Aufwand, mehr Output
  • Direkt im Browser starten – ohne In­stal­la­ti­on

CRUD-Frame­works: Zu­griffs­schicht für Da­ten­ban­ken

Sind einzelne Da­ten­ob­jek­te mithilfe einer gra­fi­schen Ober­flä­che vi­sua­li­siert und durch die genannten CRUD-Ope­ra­tio­nen ver­än­der­bar, spricht man von einem CRUD-Framework oder auch einem CRUD-Grid. Für ge­wöhn­lich handelt es sich bei den Ober­flä­chen um HTML-In­ter­faces. Ein CRUD-Framework setzt mehrere Trans­ak­ti­ons­schrit­te voraus, sodass Daten bei­spiels­wei­se nicht durch die einfache Eingabe, sondern erst nach Drücken eines „Speichern“- oder „Weiter“-Buttons über­nom­men werden. Die Ope­ra­tio­nen eines CRUD-Frame­works lassen sich zeitlich stark versetzt ausführen, ohne dass der Datensatz für diese Zeit­span­ne für andere Nutzer gesperrt wird. Ins­be­son­de­re für Mehr­be­nut­zer­sys­te­me ist diese Tatsache von großer Bedeutung, da somit mehrere Personen gleich­zei­tig denselben Da­ten­be­stand auslesen können.

Zur Umsetzung der Ope­ra­tio­nen werden so­ge­nann­te Per­sis­tenz-Schichten verwendet, die in der Regel in Form von Er­wei­te­run­gen (Modulen) im Framework enthalten sind oder im­ple­men­tiert werden können. Diese schlüs­seln die re­la­tio­na­le, ta­bel­la­ri­sche Re­prä­sen­ta­ti­on der Da­ten­be­stän­de auf und prä­sen­tie­ren selbige statt­des­sen auf einer ob­jekt­ori­en­tier­ten Ebene. CRUD-Frame­works er­leich­tern durch den op­ti­mier­ten Zugriff auf das genutzte Da­ten­bank­sys­tem sowohl die Ent­wick­lung als auch die Nutzung von An­wen­dun­gen. Es gibt zahl­rei­che Frame­works mit CRUD-Konzept, die auf den un­ter­schied­lichs­ten Sprachen und Platt­for­men basieren. Einige Beispiele finden Sie in der folgenden ta­bel­la­ri­schen Übersicht:

Sprache bzw. Plattform Framework
Java JDBC (The Java Database Con­nec­ti­vi­ty), Hibernate, JBoss Seam, Isis
PHP Yii, CakePHP, Zikula, Symfony, TYPO3 Flow
Perl Catalyst, Gantry
Python Django, SQL­Al­che­my, web2py
Groovy Grails
.NET NHi­ber­na­te, ADO.NET/Entity Framework
Ruby Ruby on Rails
Ja­va­Script Backbone.js, AngularJS

So ent­wi­ckeln Sie ein CRUD-PHP-Grid für Ihre Datenbank

In den folgenden Ab­schnit­ten zeigen wir Ihnen, wie Sie für das ver­brei­tets­te Da­ten­bank­sys­tem MySQL ein Bootstrap-Interface erstellen, das den Zugriff per CRUD-Ope­ra­tio­nen er­mög­licht. Ferner soll auch bereits die create-Operation ein­ge­rich­tet werden. Um die Da­ten­bank­ta­bel­len ent­spre­chend zu ma­ni­pu­lie­ren, wird die ser­ver­sei­ti­ge Skript­spra­che PHP mithilfe der Er­wei­te­rung PHP Data Objects (PDO) verwendet.

1. Im ersten Schritt geht es darum, eine einfache Da­ten­bank­ta­bel­le anzulegen, die im späteren Verlauf   dieses Tutorials per CRUD-Zugriff ma­ni­pu­liert werden soll. Im­por­tie­ren Sie zu diesem Zweck die folgende Beispiel-Tabelle in Ihre MySQL-Datenbank:

CREATE TABLE `customers` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`name` VARCHAR( 100 ) NOT NULL ,
`email` VARCHAR( 100 ) NOT NULL ,
`mobile` VARCHAR( 100 ) NOT NULL
) ENGINE = INNODB;

Die Tabelle dient der Sammlung von Nutzer-In­for­ma­tio­nen – Name, E-Mail-Adresse und Mo­bil­num­mer. Jeder Eintrag erhält au­to­ma­tisch einen Primary Key (AUTO_INCREMENT PRIMARY KEY) – also eine eigene in­di­vi­du­el­le ID.

2. An­schlie­ßend gilt es, den Ver­bin­dungs­auf­bau und -abbau zur Datenbank zu regeln. Erstellen Sie eine PHP-Datei mit dem Namen database.php und fügen das folgende Skript mit der Klasse „Database“ zur Ver­wal­tung der Datenbank-Ver­bin­dun­gen ein:

<?php
class Database 
{
private static $dbName = 'name_der_datenbank'; 
private static $dbHost = 'localhost';
private static $dbUsername = 'nutzername';
private static $dbUserPassword = 'passwort';
private static $cont = null;
public function __construct() {
die('Init-Funktion nicht erlaubt');
}
public static function connect() {
// Nur eine Verbindung während der gesamten Zugriffsdauer zulassen
if ( null == self::$cont )
{
    try
    {
        self::$cont = new PDO( "mysql:host=".self::$dbHost.";"."dbname=".self::$dbName, self::$dbUsername, self::$dbUserPassword);
    }
    catch(PDOException $e)
    {
        die($e->getMessage());
    }
} 
return self::$cont;
}
public static function disconnect()
{
self::$cont = null;
}
}

Damit auch Sie die hier de­fi­nier­te Klasse für den Da­ten­bank­zu­griff mit PDO nutzen können, müssen Sie die exakten Werte für die vier Einträge $dbName (Name der ver­wen­de­ten Datenbank), $dbHost (Name des Hosts, auf dem die Datenbank aus­ge­führt wird – für ge­wöhn­lich wie im Beispiel localhost), $dbU­ser­na­me (Name des zu­grei­fen­den Nutzers) und $dbU­ser­Pass­word (Passwort des zu­grei­fen­den Nutzers) angeben.

Der „Database“-Klasse wurden in diesem Skript drei Funk­tio­nen zu­ge­wie­sen: __construct(), der Kon­struk­tor der Klasse, erinnert Nutzer daran, dass die In­itia­li­sie­rung (also die Zuweisung eines Initial- oder An­fangs­wer­tes) nicht erlaubt ist. Bei connect() handelt es sich um die Haupt­funk­ti­on der Klasse, die den Ver­bin­dungs­auf­bau reguliert, das Ge­gen­stück dis­con­nect() dient dem Beenden der Ver­bin­dung.

3. Da man CRUD-Ope­ra­tio­nen nur mithilfe der passenden Ober­flä­che ausführen kann, soll an dieser Stelle nun das Basis-Grid mit Twitter Bootstrap erstellt werden. Die aktuelle Version des Frame­works finden Sie auf der of­fi­zi­el­len Homepage. Entpacken Sie Bootstrap im gleichen Ver­zeich­nis, in dem sich auch die database.php befindet, und legen Sie zu­sätz­lich eine weitere Datei mit dem Namen index.php an. In dieser erstellen Sie nun das Interface:

<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<link href="css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row">
<h3>Mein CRUD-PHP-Grid</h3>
</div>
<div class="row">
<table class="table table-striped table-bordered">
<thead>
    <tr>
        <th>Name</th>
        <th>E-Mail-Adresse</th>
        <th>Mobilnummer</th>
    </tr>
</thead>
<tbody>
<?php 
include 'database.php';
$pdo = Database::connect();
$sql = 'SELECT * FROM customers ORDER BY id DESC';
foreach ($pdo->query($sql) as $row) {
echo '<tr>';
echo '<td>' . $row['name'] . '</td>';
echo '<td>' . $row['email'] . '</td>';
echo '<td>' . $row['mobile'] . '</td>';
echo '</tr>';
}
Database::disconnect();
?>
</tbody>
</table>
</div>
</div> <!-- /container -->
</body>
</html>

Im <head>-Bereich wurden die CSS- und Ja­va­Script-Dateien von Bootstrap, im <body>-Bereich die zuvor erstellte database.php inklusive der Auf­for­de­run­gen, eine PDO-Ver­bin­dung zu errichten (Database::connect()) und die ent­spre­chen­den Daten zu beziehen (SELECT), ein­ge­bun­den. Zu­sätz­lich enthält die Datei die HTML-Tabelle <table> mit den drei Spalten Name, E-Mail-Adresse und Mo­bil­num­mer, die auch in der Datenbank ge­spei­chert werden.

4. Da damit das Grund­ge­rüst steht, geht es nun darum, die ver­schie­de­nen CRUD-Ope­ra­tio­nen zu rea­li­sie­ren. Um bei­spiels­wei­se die create-Operation zu im­ple­men­tie­ren, benötigen Sie eine weitere HMTL-Seite mit For­mu­lar­fel­dern zur Eingabe der Nut­zer­da­ten, die in der index.php verlinkt wird und sich über einen Button erreichen lässt, der dem Bootstrap-Interface hin­zu­ge­fügt wird. Der Ein­fach­heit halber können Sie mit der Er­stel­lung dieses Buttons beginnen, indem Sie erneut die index.php öffnen und das zweite <div class="row">-Element, das die Tabelle enthält, um den folgenden Code ergänzen: 

<p>
    <a href="create.php" class="btn btn-success">Create</a>
</p>

Sie können an dem Code-Schnipp­sel bereits erkennen, dass auf die Datei create.php verlinkt wird, die bisher noch gar nicht existiert. Ein Test des bis­he­ri­gen Bootstrap-Grids zeigt daher zwar den Button an; ein Klick auf selbigen führt al­ler­dings nur auf eine Feh­ler­sei­te. Um die create-Operation endgültig verfügbar zu machen, erstellen Sie besagte create.php-Datei und fügen zunächst einmal den folgenden ersten Teil des Codes ein:

<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<link href="css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="span10 offset1">
<div class="row">
<h3>Create a Customer</h3>
</div>
<form class="form-horizontal" action="create.php" method="post">
<div class="form-group <?php echo !empty($nameError)?'has-error':'';?>">
<label class="control-label">Name</label>
<div class="controls">
<input name="name" type="text" placeholder="Name" value="<?php echo !empty($name)?$name:'';?>">
<?php if (!empty($nameError)): ?>
<span class="help-inline"><?php echo   $nameError;?></span>
<?php endif; ?>
</div>
</div>
<div class="form-group <?php echo !empty($emailError)?'has-error':'';?>">
<label class="control-label">E-Mail-Adresse</label>
<div class="controls">
<input name="email" type="text" placeholder="E-Mail-Adresse" value="<?php echo !empty($email)?$email:'';?>">
<?php if (!empty($emailError)): ?>
<span class="help-inline"><?php echo   $emailError;?></span>
<?php endif;?>
</div>
</div>
<div class="form-group <?php echo !empty($mobileError)?'has-error':'';?>">
<label class="control-label">Mobilnummer</label>
<div class="controls">
<input name="mobile" type="text" placeholder="Mobilnummer" value="<?php echo !empty($mobile)?$mobile:'';?>">
<?php if (!empty($mobileError)): ?>
<span class="help-inline"><?php echo $mobileError;?></span>
<?php endif;?>
</div>
</div>
<div class="form-actions">
<button type="submit" class="btn btn-success">Create</button>
<a class="btn" href="index.php">Back</a>
</div>
</form>
</div>
</div> <!-- /container -->
</body>
</html>

Der Code erzeugt das HTML-Formular, in das die einzelnen Angaben zu Name, Mo­bil­num­mer und E-Mail-Adresse gemacht werden können. Für jedes Eingabe-Feld ist zu­sätz­lich eine PHP-Variable eingebaut, die in Kom­bi­na­ti­on mit der nun folgenden Er­wei­te­rung des Codes (dieser ist noch vor dem HTML-Code in die create.php ein­zu­fü­gen) Feh­ler­mel­dun­gen erzeugt, insofern das be­tref­fen­de Feld bei der Eingabe frei bleibt:

<?php 
require 'database.php';
if ( !empty($_POST)) {
// Validierungsfehler erfassen
$nameError = null;
$emailError = null;
$mobileError = null;
// Eingabewerte erfassen
$name = $_POST['name'];
$email = $_POST['email'];
$mobile = $_POST['mobile'];
// Eingabe validieren
$valid = true;
if (empty($name)) {
$nameError = 'Bitte geben Sie einen Namen an';
$valid = false;
}
if (empty($email)) {
$emailError = 'Bitte geben Sie eine E-Mail-Adresse an';
$valid = false;
} else if ( !filter_var($email,FILTER_VALIDATE_EMAIL) ) {
$emailError = 'Bitte geben Sie eine gültige E-Mail-Adresse an';
$valid = false;
}
if (empty($mobile)) {
$mobileError = 'Bitte geben Sie eine Mobilnummer an';
$valid = false;
}
// Daten eingeben
if ($valid) {
    $pdo = Database::connect();
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $sql = "INSERT INTO customers (name,email,mobile) values(?, ?, ?)";
    $q = $pdo->prepare($sql);
    $q->execute(array($name,$email,$mobile));
    Database::disconnect();
    header("Location: index.php");
}
     }
?>

Damit haben Sie nun eine create.php-Seite erstellt, die bei einem Klick auf den create-Button auf­ge­ru­fen wird und die Eingabe der Nut­zer­in­for­ma­tio­nen er­mög­licht. Das Skript stellt sicher, dass alle ein­ge­ge­be­nen Daten sowie Va­li­die­rungs­feh­ler erfasst werden, bei falscher Eingabe ent­spre­chen­de Feh­ler­mel­dun­gen er­schei­nen und dass die Daten an die de­kla­rier­te Datenbank wei­ter­ge­lei­tet werden. Wie Sie auch die anderen CRUD-Ope­ra­tio­nen read, update und delete erstellen bzw. nutzen können, erfahren Sie in diesem Tutorial, das auch noch einmal die Er­stel­lung des Bootstrap-Grids sowie der create-Operation erklärt.

Zum Hauptmenü