MySQL

xampp, mamp, Apache, PHP, MySQL. Wie installiert man das (xampplite) und wie sind die Zusammenhänge.

Während die Firma Sun in den neunziger Jahren behauptete: „Der Computer ist das Netz“, wollte die Firma Microsoft erst ruhen, wenn auf jedem Schreibtisch ein Computer mit Windows steht. Dieser Teil der Geschichte hat sich erfüllt. Microsoft könnte „ruhen“ und sucht auch tatsächlich aktiv nach neuen Märkten und Produkten.

Der Rechner, um den es Microsoft ging, war immer eine Mixtur aus Datendateien und Binärdateien. Die Dateien mit den binären Inhalten nennt man Programme. Sie wurden von den Kunden gekauft und installiert, um damit die Daten bearbeiten zu können. Microsoft Office erlebte einen Siegeszug durch die meisten Büros dieser Welt.

Der Rechner, um den es der Firma Sun ging, war eher ein Dumb Tube. Ein billiges, dummes Endgerät mit einem Bildschirm, einer Tastatur, einer Maus und einem Zugang ins Internet. Die Programme und die Daten sollten sich nicht auf diesem Rechner befinden, sondern irgendwo im Netz.

Die Philosophie von Microsoft tendierte also mehr in die Richtung meines, die Philosophie von Sun mehr in die Richtung unser.

Die Triebfedern dieser Philosophien waren in beiden Fällen wirtschaftliches Interesse. Microsoft verkaufte in erster Linie im Konsumentenbereich Software für PC, Sun dagegen im Unternehmensumfeld Server-Hardware und die passenden Programme dazu.

Mitte der neunziger Jahre erfolgte die explosionsartige Verbreitung des eigentlich schon in den sechziger Jahren erfundenen Internets unter anderem durch HTML (Hyper Text Markup Language, die Sprache, in der Webseiten geschrieben werden) und die Entwicklung von Webservern und Webclients (Browsern).

Das Internet selbst ist nur ein Satz von Spielregeln, der von verschiedenen Geräten verstanden und so geschickt kombiniert werden kann, dass dieses Netz in kürzester Zeit den gesamten Planeten überzog.

Ohne eine E-Mail-Adresse war der einzelne Mensch nicht erreichbar, und ohne eine Website war eine Firma nicht nur altmodisch, sondern in den Augen vieler Kunden nicht mehr existent. Die ganze Welt drängelte also in kurzer Zeit in dieses Netz, um ein Teil davon zu werden. Filme wie Matrix¹ wurden Kassenschlager, und 1984² von George Orwell wurde erfolgreich verdrängt.

Die, die es gewohnt waren, Programme zu kaufen, kauften HTML-Editoren und erstellten damit Internetseiten. Die anderen schrieben den HTML-Code meist lieber gleich selbst in einem ohnehin vorhandenen Texteditor. Die Webagentur war geboren, bei der man Websites in Auftrag geben konnte.

Beide Gruppen hatten allerdings das Problem, dass HTML-Seiten statisch sind. Um den Inhalt der Seite zu ändern, muss man sie am heimischen PC bearbeiten und danach wieder auf den Server kopieren.

Das war nicht nur unbequem und teuer, damit waren auch Webauftritte wie eBay oder Amazon unmöglich.

Beide Gruppen fanden mehr oder weniger gute Lösungen für das Problem.

In der meines-Fraktion entstanden schnell binäre Programme, mit denen man HTML-Seiten erzeugen konnte und diese dann per automatisiertem Verfahren auf den Server lud. In die Seiten wurden interaktive Elemente wie Besucherzähler u.Ä. eingebaut.

Die unser-Fraktion entdeckte Java Applets und damit die Möglichkeit, ein Programm zu schreiben, das zentral auf einem Server liegt und über einen Browser bedienbar ist. Auf dieser Lösung beruhten ganze Geschäftsideen wie Online-Broking und Flugbuchungskonzepte.

Beide Gruppen versuchten auf verschiedene Arten, ihre Marktanteile auszubauen. Das Ergebnis war ein recht stabiler Markt für beide, in dem »Religionskämpfe« über das richtige Betriebssystem (Windows, Linux, Mac OS X) ständig die Versionsnummern der Programme hochtrieben und sich die Kunden daran gewöhnten, dass das alles nicht so einfach ist.

In solchen Situationen gibt es immer einen dritten Weg. In unserem Fall ist das unter anderem die Entstehung von Open Source-Scriptsprachen wie PHP³. Rasmus Lerdorf hatte das Ziel, seine Homepage mit interaktiven Elementen zu versehen, und heraus kam eine neue Programmiersprache. PHP wurde von Anfang an optimiert auf die perfekte Zusammenarbeit mit der Datenbank MySQL, die ebenfalls unter der GNU/GPL⁴ stand.

Glücklicherweise gab es das Betriebssystem Linux und einen Webserver namens Apache, die die benötigte Infrastruktur auf dem Server boten. Das Anzeigemedium beim Kunden war der Browser, der mit Sicherheit vorhanden war. LAMP (Linux, Apache, MySQL, PHP) wurde bald das Synonym für datenbankgestützte, interaktive Auftritte im Internet.

Wie in einem kreativen Rausch entstanden verschiedenste Systeme, die es ermöglichten, Inhalte nur mithilfe eines Browsers zu organisieren, wie Forenseiten, Communities, Online-Shops, Voting-Seiten und ähnliche Dinge.

Nach den »harten« Sachen wie Linux und Apache entstanden nun die »weichen« Produkte.

Die neunziger Jahre neigten sich dem Ende zu, die Internetaktienblase platzte, und plötzlich kam es darauf an, ganz klassische Geschäftsmodelle mit ganz klassischen Methoden zu etablieren.

Immer wenn es der Wirtschaft nicht gut geht, schaut sie auf die Kosten und überlegt, ob es Möglichkeiten gibt, diese zu senken. Es gab und gibt zahlreiche Möglichkeiten!

Die PHP-Anwendungen, die es damals gab, hatten Verbreitungszahlen, die in die Millionen gingen. Als Beispiele seien hier nur die Projekte phpBB⁵ und phpMyAdmin⁶ genannt. Das eine hat sich zum Quasistandard für Foren-Software entwickelt, das andere als Standard für das Bearbeiten von MySQL-Datenbanken per Webinterface.

Der Quellcode der Sprache PHP selbst und der Quellcode der Anwendungen wurde durch die enorme Zahl von Nutzern und Entwicklern immer schneller immer besser. Je offener ein Projekt gestaltet wurde, desto erfolgreicher wurde es.

Einzelne Gurus konnten Unternehmen in kürzester Zeit immense Kosten sparen.

Statische HTML-Seiten galten als alt, teuer und überholt. Dynamisch musste es sein! In diesem Umfeld bewegen wir uns jetzt seit einem Jahrzehnt. Linux, Apache, MySQL und PHP sind in der Industrie akzeptiert. Die Suche nach professionell verwertbaren PHP-Anwendungen begann.

Bei dieser Suche schaut man auf:

• Eine einfache Installation
• Eine gute Wartbarkeit des Quellcodes
• Die Sicherheit des Quellcodes
• Die Benutzerfreundlichkeit
• Die einfache Erweiterbarkeit
• Die einfache Entwicklung
• Die einfache Einarbeitung für neue Entwickler
• Standardisierte Schnittstellen zu anderen Programmen
• Die Kosten
• Die Unabhängigkeit vom Lieferanten

Der besondere Vorteil von PHP-Anwendungen ist die Unabhängigkeit von Hardware und Betriebssystem. LAMP existiert auch als WAMP für Windows, MAMP für den Apple und auf zahlreichen anderen Plattformen.

Und jetzt kommt endlich Joomla! ins Spiel.

Joomla! – wie kam es dazu?

Die australische Firma Miro⁷ entwickelte im Jahre 2001 ein Content Management System namens Mambo. Sie stellte dieses System als Open Source-Software zur Verfügung, um es auszutesten und für eine weite Verbreitung zu sorgen. Im Jahre 2002 spaltete die Firma ihr Produkt Mambo in eine kommerzielle und eine Open Source-Version. Die kommerzielle Variante nannte man Mambo CMS, die Open Source-Version Mambo Open Source oder kurz MOS. Ende 2004 haben sich alle Beteiligten darauf geeinigt, dass MOS ganz offiziell Mambo genannt werden darf und dass man gemeinsam eine erfolgreiche Zukunft für das sich damals am schnellsten entwickelnde CMS gestaltet.

Die Vorteile der kommerziellen Variante lagen für Firmen in erster Linie in der erhöhten Sicherheit und in der Tatsache, dass sie die Firma Miro als Ansprechpartner hatten, die auch die weitere Entwicklung unterstützen würde.

Die Vorteile der Open Source-Version sind, dass sie »frei« ist und dass eine riesige Gemeinde von Benutzern und Entwicklern für eine zügige Weiterentwicklung sorgt. Außerdem ist es für Unternehmen natürlich möglich, Mambo als Basis zu nehmen und darauf aufbauend eigene Lösungen zu entwickeln.

Im Jahre 2005 gab es auf allen Seiten Überlegungen, eine Stiftung für die Open Source-Variante von Mambo einzurichten, um die Existenz und Weiterentwicklung zu sichern.

Im Herbst 2005 wurde auf der Mambo-Projektseite die Gründung einer Mambo-Foundation als Meldung veröffentlicht. Nach positiven Reaktionen in den ersten Stunden stellte sich heraus, dass die Stiftung von Miro in Australien gegründet und das Entwicklerteam nicht in die Gründungsmodalitäten einbezogen wurde. Daraufhin entbrannten heiße Diskussionen in den Foren der Community, und ein paar Tage lang gab es keine Äußerung vom Entwicklerteam.

Nach kurzer Zeit veröffentlichte das Entwicklerteam eine Stellungnahme unter der URL opensourcematters.org und kündigte an, dass es sich vom neutralen Software Freedom Law Center⁸ beraten lassen und eine Weiterentwicklung von Mambo unter eigener Verantwortung planen würde. Schon damals geisterte die Idee einer verbesserten Mambo- Version mit neuer Quellcode-Basis durch die Foren.

Wie in einer zerrütteten Ehe entwickelte sich schnell ein Rosenkrieg zwischen der von Miro dominierten Mambo-Foundation, der plötzlich das Entwicklungsteam abhanden gekommen war, dem Entwicklungsteam selbst, das natürlich einen neuen Namen für den Fork benötigte, und einer erhitzten internationalen Community von hunderttausenden Benutzern, die sich teilweise mit harten Worten in Blogs, Foren und den jeweiligen Projektseiten beharkten.

Beide Projekte wurden weitergeführt. Der Fork wurde Joomla! genannt.

Das Joomla!-Team legte einen sehr großen Wert auf die Einhaltung von demokratischen Regeln. Das neue Projekt benötigte ein Logo, und so wurde ein Wettbewerb in der „neuen“ Community ausgerufen. Im neuen Forum hatten sich bis dahin in ein paar Tagen 8.000 Benutzer registriert. Die Vorschläge und die Ergebnisse sind natürlich online zu sehen⁹.

Die Mambo-Foundation stellte schnell ein neues Entwicklerteam vor.

Am 17.9.2005 wurde die Version 1.0 von Joomla! veröffentlicht.

Aus der Welt der so genannten Third Party-Entwickler, also Programmiergruppen, die Mambo-Komponenten entwickelten, wechselten die Projekte Simpleboard (heute FireBoard), Docman und viele andere schnell zu Joomla! und haben dadurch das Vertrauen in das neue Projekt bekräftigt. Aus der Vorsilbe „mos“, die in vielen Variablen und Begriffen benutzt wurde, wurde schnell „jos“.

Eine ausführliche Zusammenfassung der Ereignisse in englischer Sprache finden Sie im Internet¹⁰.

Joomla! gehört zwei Jahre nach seiner Gründung zu den populärsten Open Source-Projekten der Welt.

Allerdings sind in diesen zwei Jahren durch die Neuorganisation viel Zeit mit organisatorischen Grabenkriegen und interkulturellen Mißverständnissen vertan worden.

Das Web 2.0 feierte seine Siegeszüge. Von Benutzern erzeugter Inhalt wurde immer wichtiger. Second Life mit seiner virtuellen Umgebung wurde weltweit bekannt. Die Programmiersprache Ruby und insbesondere Ruby on Rails wurden mehr und mehr zur Entwicklung von Webseiten genutzt. Programmierschnittstellen spielten eine immer größere Rolle.

In diesem Bereich sah und sieht Joomla 1.0.x einfach schon ein bischen alt und grau aus. Es ist zwar nicht am Ende seiner Weiterentwicklungsmöglichkeiten, aber die Benutzer schielten manchmal schon ein wenig traurig auf die Fähigkeiten von Systemen wie Plone, Typo3, Drupal und vielen anderen, die nicht das Problem der schieren Größe und der Umorganisation hatten und die neuen Techniken stetig in ihre Projekte aufnahmen.

Seit zwei Jahren wird Joomla! in der Version 1.0.x nicht wirklich weiterentwickelt, sondern es wurden in erster Linie Sicherheitsupdates mit kleineren Code-Änderungen herausgegeben. Zwei Jahre Wartezeit auf eine neue Version sind kein Aushängeschild für das Projekt. Joomla! wurde in dieser Zeit oft totgesagt, belächelt, und in der Fachpresse erschienen teilweise hämische Artikel über das Thema: „Wie ruiniere ich ein tolles Softwareprojekt?“.

Mit der neuen Version Joomla! 1.5 ist dem Projektteam allerdings in sehr guter Wurf gelungen. Nachdem nun wirklich alles in Forum, Mailing Listen, E-Mail und persönlichen Treffen ausdiskutiert wurde, sieht heute die Zukunft von Joomla! besser aus als je zuvor.

Der Umstieg von der Version 1.0.x auf 1.5.x wird auf der einen Seite noch viel Kraft kosten, da durch den geänderten Quellcode keine vollständige Abwärtskompatibilität besteht. Es wird aber auf der anderen Seite Joomla! endgültig in die Liga der Business-tauglichen Content Management Systeme katapultieren. Die Strategie, aus Joomla! einen Baukasten zu erstellen (Joomla! Framework), mit dem Entwickler an den neuen Entwicklungen teilnehmen können, ist geschickt gewählt und wird sich auszahlen.

Endlich ist es auch möglich, verschiedene Authentifizierungsmethoden zu wählen, barrierefreie Websites in unterschiedlichen Sprachen zu erstellen und an der allgegenwärtigen Mashup-Welle¹¹, die jetzt auch deutlich in die Unternehmen schwappt, teilzunehmen. Auch der Weg zur Komponentenentwicklung in einer Umgebung wie Eclipse ist nun möglich.

Bei der vorhandenen Community-, Entwickler- und Installationsdichte wird Joomla! viele Bereiche dieses Marktes einfach abdecken. Viele Hosting-Provider bieten Joomla! heute schon vorinstalliert ihren Kunden an, und die neue Version 1.5 ist zur Version 1.0.x zumindest so kompatibel, dass es keine ernsthaften Probleme bei einem Umstieg von einfachen Websites geben wird.

Jetzt einen großen Sprung nach vorn in Richtung Komplexität. Wir wollen eine sehr einfache Gebrauchtwagen-Liste erstellen, die über den Administrationsbereich gepflegt werden kann.

Sie benötigen dazu:

• eine neue Frontend-Komponente,
• eine Backend-Komponente,
• eine spezielle Tabelle in der Datenbank,
• (optional) ein zusätzliches Modul zur Anzeige der Einträge auf der Website und
• (optional) ein Such-Plugin, um Ihre neuen Inhalte durchsuchen zu können.

Damit Sie eine Vorstellung bekommen, worauf ich hinaus möchte und wie die Liste auf der Website aussehen soll, hier das fertige Beispiel. Installieren Sie sich einfach die Komponente com_auto.zip, um es selbst nachvollziehen zu können.

Auf der Website soll eine Liste von Autos mit einem kleinen Foto erscheinen. Klickt man auf das Foto, öffnet sich ein Fenster mit einem größeren Foto. Außerdem gibt es noch ein Modul mit einer Auflistung der Autos (Abbildung 15.5).

Abbildung 15.5: Eigene Komponente auf der Website

Diese Liste enthält in unserem Falle Autotypen. Sie können das Beispiel auch mit anderen Daten füllen (Niederlassungen, Angebote etc.). Für den Besucher der Website reicht es meistens aus, eine solche Liste zu sehen. Er muss die Einträge nicht bearbeiten können.

Der Administrator dagegen muss die Liste verwalten.

Verwalten bedeutet in diesem Zusammenhang:

• Neue Einträge aufnehmen
• Vorhandene Einträge ändern
• Vorhandene Einträge löschen

Um das Beispiel nicht zu verkomplizieren, zeigen und bearbeiten wir vier Felder. Zwei Felder für den Text (Typ, Hersteller) und zwei Felder für die Fotos (URL zum Foto, klein und groß). Das Prinzip der Programmierung einer Komponente in Joomla! wird so deutlich, und Sie können das Beispiel leicht um mehrere Felder erweitern. Die Komponente soll sich in die vorhandene Administrationsstruktur einfügen. Die Verwaltungsoberfläche im Administrationsbereich soll aussehen wie in Abbildung 15.6. Es soll möglich sein, die oben genannten Funktionen auszuführen. Außerdem benötigen Sie natürlich eine spezielle Toolbar für die Listenanzeige und eine für den Editier-Modus. Sie benötigen eine Möglichkeit, die Einträge zu veröffentlichen und zu sperren, und Sie wollen die Funktionen Veröffentlichen und Löschen natürlich auch in einer Mehrfachverarbeitung haben, indem Sie die Checkboxen vor den Einträgen ankreuzen und dann beispielsweise mehrere Einträge auf einmal veröffentlichen.

Abbildung 15.6: Eigene Komponente in der Joomla!-Administration als Liste

Außer der Liste benötigen Sie natürlich noch ein Formular für das Ändern und Neuanlegen eines Eintrags (Abbildung 15.7).

Abbildung 15.7: Eigene Komponente in der Joomla!-Administration als Formular

Beginnen wir mit der Komponente. Ich nenne sie com_auto. Um die Ausführungen hier nachvollziehen zu können, sollten Sie sich das fertige Beispiel herunterladen¹ und wie jede Komponente installieren. Sie können diese Komponente dann per Hand ändern. Das Ändern und Umbauen hat den Vorteil, dass Sie nach und nach die Strukturen durchschauen und vielleicht Lust auf mehr bekommen. Ich gebe zu, dass komplexere Code-Beispiele schnell unübersichtlich werden. Ich habe aber in diesem Fall versucht, die Dateien so kurz wie möglich zu gestalten, ohne wichtige Dinge wegzulassen.

15.2.1 Die MySQL-Tabelle

Die Komponente nutzt eine Tabelle in MySQL, um die Autos zu speichern. Die Tabelle wird automatisch bei der Installation angelegt. Die SQL-Befehle finden Sie nach der Installation in der Datei /administrator/com_auto/install.sql. Analog dazu gibt es eine Datei uninstall.sql, die bei der Deinstallation der Komponente die Tabelle wieder löscht.

Wenn Sie http://localhost/phpmyadmin aufrufen, können Sie sich die Tabelle jos_auto ansehen (Abbildung 15.8).

Abbildung 15.8: Auto-Tabelle in MySQL

Das Präfix jos_ wird vom Installer vergeben, abhängig von den Angaben in Ihrer Joomla!-Konfiguration. Das Feld published enthält entweder den Wert 1 (veröffentlicht) oder 0 (nicht veröffentlicht). Die beiden Fotos enthalten einen Pfad, den Sie vermutlich anpassen müssen. Das können Sie in der Administration tun. Die Bilder sind ebenfalls auf der dem Buch beiliegenden CD enthalten.

15.2.2 Das Frontend

Wir beginnen mit der Liste der Autos im Frontend. Wie bereits bei der hallo-Komponente benötigen Sie die folgenden Dateien:

• /components/com_auto/auto.php
• /components/com_auto/controller.php
• /components/com_auto/views/auto/view.html.php
• /components/com_auto/views/auto/tmpl/default.php
• /components/com_auto/models/auto.php

Wie Sie sehen, existiert dieses Mal ein model, wir benötigen ja Daten aus einer Datenbank.

Der Einstiegspunkt (/components/com_auto/auto.php)

Auch gibt es einen Einstiegspunkt. Die Datei /components/com_auto/auto.php sammelt alles zusammen und delegiert die Aufgaben (Listing 15.6).

<?php
// kein direkter Zugriff
defined('_JEXEC') or die('Restricted   access');
// laden des Joomla! Basis Controllers
require_once   (JPATH_COMPONENT.DS.'controller.php');
// Erzeugen eines   Controllers 
$controller = new AutoController(); 
// den   request task   auslesen
$controller->execute(JRequest::getCmd('task'));
// Redirect aus dem controller
$controller->redirect();
?>

Listing 15.6: /components/com_auto/auto.php

Der Code ist fast der gleiche wie in der com_hallo-Komponente (Stichwort Wiederverwendbarkeit) (Listing 15.7).

Der Controller (/components/com_auto/controller.php)

Auch hier alles bekannte Dinge aus der com_hallo-Komponente:

<?php
defined('_JEXEC')   or die();
jimport('joomla.application.component.controller');
class   AutoController extends JController{
  function display(){
    parent::display();
  }
}

Listing 15.7: /components/com_auto/controller.php

Der View (/components/com_auto/views/auto/view.html.php)

Hier finden sich erste Unterschiede. Wir benötigen natürlich Daten für die Liste (Listing 15.8).

<?php
jimport('joomla.application.component.view');
class AutoViewAuto extends JView {
  function display($tpl = null){
    $model =   &$this->getModel();
    $rows =   $model->getAutoList();
    $this->assignRef('rows'   , $rows);
    parent::display($tpl);
  }    
}
?>

Listing 15.8: /components/com_auto/views/auto/view.html.php

$model = &$this->getModel();

Das Modell wird instanziert und steht als Objekt in der Variable $model zur Verfügung

$rows = $model->getAutoList();

Die Methode getAutoList wird im Objekt aufgerufen und liefert ein Array $rows (Zeilen) zurück.

$this->assignRef('rows', $rows);
parent::display($tpl);

Die Ergebniszeilen werden zugewiesen und an das Template weitergegeben.

Das Template (/components/com_auto/views/auto/tmpl/default.php)

Im Standard-Template werden die Zeilen in der Variable $rows durch eine for-Schleife geschickt, in eine einzelne $row verwandelt und dann einzeln ausgegeben (Listing 15.9)

<?php 
defined('_JEXEC') or die('Restricted access'); 
?>
<script type="text/javascript">
function FensterOeffnen   (Adresse) {
  MeinFenster = window.open(Adresse, "Auto", 
     "width=400,height=300,left=100,top=200");
  MeinFenster.focus();
}
</script>
<h1><?php echo "&Uuml;berschrift"; ?></h1>
<ul>
  <?php
  // Auslesen der Datensätze im Array
  foreach ($this->rows as $row) {
  ?>
  <li>
  <?php echo $row->text; ?>
  <small><em>(<?php echo   $row->hersteller; ?>)
  </em></small><br>
  <a href="<?php echo $row->photo_gross; ?>"   
     onclick="FensterOeffnen(this.href); return false">
  <img src=<?php echo $row->photo_klein; ?>></a>
  </li>
  <?php
}
?>
</ul>

Listing 15.9: /components/com_auto/views/auto/tmpl/default.php

foreach($this->rows as $row){
  ?>
  <li>
  <?php echo $row->text; ?>
  <?php echo $row->hersteller; ?>
  <?php echo $row->photo_klein;   ?>
  </li>
  <?php
} 
?>

Diese Schleife ist das eigentlich Wichtige an diesem Template. Die restliche Formatierung mit HTML oder wie im Besipielcode mit JavaScript zum Öffnen des Popup-Fensters können Sie beliebig verkomplizieren, mit Lightbox-Effekten versehen und alles, was beispielsweise Dreamweaver, MooTools und Ihre Kreativität hergeben, einbauen. Dieser Teil der Formatierung ist in der Version Joomla! 1.5 jetzt eigenständig, bis auf die Variable $rows.

Model (/components/com_auto/models/auto.php)

Da war doch noch etwas – das Modell! Wie kommen wir an die Daten? (Listing 15.10)

<?php
defined('_JEXEC') or die();
jimport('joomla.application.component.model');
class   AutoModelAuto extends JModel{
  function _getAutoQuery( &$options ){
    $db = JFactory::getDBO();
    $id =   @$options['id'];
    $select = 'a.*';
    $from = '#__auto   AS a';
    $wheres[] = 'a.published = 1';
    $query = "SELECT   " . $select .
             "\n   FROM " . $from .
             "\n   WHERE " . implode( "\n  AND ", $wheres );
    return $query;
  }
  function getAutoList( $options=array() ){
    $query = $this->_getAutoQuery( $options );
    $result = $this->_getList( $query );
    return @$result;
  }
}
?>

Listing 15.10: /components/com_auto/models/auto.php

Es gibt zwei wichtige Methoden im Modell. Das ist zum einen die Methode _getAutoQuery, die den Zugriff auf die Daten realisiert und den SQL-Befehl beinhaltet, und zum anderen die Methode getAutolist, die diesen Zugriff steuert und das Resultat zurückgibt. Sie können sich sicherlich noch an die Datei views.html.php erinnern. Dort gibt es diese Zeile:

$rows = $model->getAutoList();

Sie greift auf das Objekt des Modells zu und speichert das Ergebnis in $rows. Innerhalb der Klasse AutoModelAuto wird diese Rückgabe durch die Methode getAutoList realisiert.

Fazit

Es ist an der Zeit, sich mit PHP und objektorientierter Programmierung zu befassen. Ohne das Wissen um Klassen, Methoden, Vererbung und ähnlichen Dingen sind sie nicht unbedingt verloren, aber doch vermutlich verwirrt.

Wenn man sich aber erst mal auf den MVC-Pfad von Joomla! einlässt, sieht man schnell Zusammenhänge. Wenn Sie beispielsweise die com_hallo-Komponente mit diesem Teil der com_auto-Komponente vergleichen, so waren eigentlich 80% des Codes identisch (bis auf das Modell).

15.2.3 Die com_auto-Administration

War das reine Anzeigen der Daten auf der Website noch verhältnismäßig einfach, so ist das Verwalten der Daten naturgemäß ein wenig aufwändiger. Hier müssen Sie die Daten als Administrator anzeigen, ändern, neu einfügen, löschen und veröffentlichen können – also erheblich mehr Interaktivität als in der einfachen Liste auf der Website.

Die Komponenten-Tabelle

Joomla! verwaltet übrigens alle Menüeinträge der Komponenten in der Tabelle [prefix]components. Auch die Menüeinträge aller Komponenten im Administrationsbereich müssen hier vermerkt werden. Die com_auto-Komponente wurde dort auch eingetragen (Abbildung 15.9).

Abbildung 15.9: Die components Tabelle in phpMyAdmin

Außerdem wird dort eine Grafik vermerkt, die links neben dem Menü erscheinen soll ('js/ThemeOffice/component.png'). Die Grafiken finden Sie im Ordner [PfadzuJoomla]/includes/js/ThemeOffice. (Abbildung 15.10).

Abbildung 15.10: Grafik neben den Menüeinträgen

Um die Administrationskomponente zu erstellen, benötigen Sie mehrere Dateien. Im Verzeichnis [PfadzuJoomla]/administration/components/com_auto/ finden Sie:

• /administration/components/admin.auto.php
• /administration/components/controller.php
• /administration/components/controllers/auto.php
• /administration/components/views/autos/view.html.php
• /administration/components/views/autos/tmpl/default.php
• /administration/components/views/auto/view.html.php
• /administration/components/views/auto/tmpl/form.php
• /administration/components/tables/auto.php
• /administration/components/install.sql
• /administration/components/uninstall.sql

Der Einstieg (/administration/components/admin.auto.php)

Auch im Administrationsbereich gibt es natürlich einen Einstieg (Listing 15.11).

<?php
defined('_JEXEC') or die('Restricted access');
$controller = JRequest::getVar('controller', 'auto'); 
require_once(JPATH_ADMINISTRATOR.DS.'controllers'.DS.$controller.'.php';
$classname = 'AutosController'.$controller;
$controller = new $classname();
$controller->execute( JRequest::getVar('task'));
$controller->redirect();
?>

Listing 15.11: /administration/components/admin.auto.php

Als Spezialist für Einstiege stellen wir fest, dass uns das schon sehr bekannt vorkommt. Bis auf die if-Abfrage, in der nach zusätzlichen Controllern gesucht wird, ist uns alles vertraut.

Controller (/administration/components/controller.php)

Auch der Basis Controller kommt uns bekannt vor (Listing 15.12):

<?php
jimport('joomla.application.component.controller');
class   AutosController extends JController{
  function display(){
    parent::display();
  }
}
?>

Listing 15.12: /administration/components/controller.php

Noch ein Controller (/administration/components/controllers/auto.php)

Jetzt ändert sich etwas. Wir haben einen zusätzlichen Controller, und der hat es auch gleich in sich (Listing 15.13):

<?php
defined('_JEXEC')   or die();
class AutosControllerAuto extends AutosController{
  function __construct(){
    parent::__construct();
    $this->registerTask( 'add', 'edit' );
    $this->registerTask(   'unpublish', 'publish');
  }
  function edit(){
    JRequest::setVar( 'view', 'auto' );
    JRequest::setVar(   'layout', 'form'  );
    JRequest::setVar('hidemainmenu', 1);
    parent::display();
  }
  function save(){
    $model = $this->getModel('auto');
    if($model->store($post)) {
      $msg = JText::_( 'Auto Saved!'   );
    }
    else{
      $msg = JText::_( 'Error Saving Auto' );
    }
    $link = 'index.php?option=com_auto';
    $this->setRedirect($link, $msg);
  }
  function remove(){
    $model = $this->getModel('auto');
    if(!$model->delete()){
      $msg = JText::_( 'Error: One or more Autos could not be   Deleted' );
    }
    else {
      $msg =   JText::_( 'Auto(s) Deleted' );
    }
    $this->setRedirect(   'index.php?option=com_auto', $msg );
  }
  function publish(){
    $this->setRedirect( 'index.php?option=com_auto' );
    $db =& JFactory::getDBO();
    $user =&   JFactory::getUser();
    $cid = JRequest::getVar( 'cid',   array(), 'post', 'array' );
    $task = JRequest::getCmd(   'task' );
    $publish = ($task == 'publish');
    $n =   count( $cid );
    if (empty( $cid )) {
      return   JError::raiseWarning( 500, JText::_( 'No items selected' ) );
    }
    JArrayHelper::toInteger( $cid );
    $cids = implode(   ',', $cid );
    $query = 'UPDATE #__auto'
           . ' SET published = ' . (int) $publish
           . ' WHERE id IN ( '. $cids .' )';
    $db->setQuery( $query );
    if (!$db->query())   {
      return JError::raiseWarning( 500,   $row->getError() );
    }
    $this->setMessage(
         JText::sprintf( $publish ? 
                'Items published' : 
                'Items unpublished', $n ) );
  }
  function cancel(){
    $msg =   JText::_( 'Operation Cancelled' );
    $this->setRedirect(   'index.php?option=com_auto', $msg );
  }
}
?>

Listing 15.13: /administration/components/controllers/auto.php

Dieser Controller implementiert die Methoden edit, save, remove, publish und cancel. Innerhalb dieser Methoden wird das Modell instanziert und je nach Bedarf beispielsweise die store-Methode im Modell aufgerufen. Mit den statischen Klassen JText und JError werden Nachrichten über den Erfolg oder Misserfolg ausgegeben (Abbildung 15.11).

Abbildung 15.11: Meldungsfenster JText

View für die Liste (/administration/components/views/autos/view.html.php)

Diesmal ist der View ein wenig größer, weil die Toolbar noch eingefügt werden muss (Listing 15.14).

<?php
defined('_JEXEC')   or die();
jimport( 'joomla.application.component.view' );
class   AutosViewAutos extends JView{
  function display($tpl = null){
    JToolBarHelper::title(   JText::_( 'Auto Manager' ),   'generic.png' );
    JToolBarHelper::publishList();
    JToolBarHelper::unpublishList();
    JToolBarHelper::deleteList();
    JToolBarHelper::editListX();
    JToolBarHelper::addNewX();
    $items = &$this->get( 'Data');
    $this->assignRef('items',    $items);
    parent::display($tpl);
  }
}

Listing 15.14: /administration/components/views/autos/view.html.php

Abbildung 15.12: Toolbar in der Liste der Autos

Die Toolbar-Helper-Klasse übernimmt die Anzeige (Abbildung 15.12).

Template Liste (/administration/components/views/autos/tmpl/default.php)

Die Liste muss natürlich auch formatiert werden, und so wird hier das entsprechende Standard-Template bereitgestellt (Listing 15.15).

<?php   
defined('_JEXEC') 
or die('Restricted access');
?>
<form action="index.php" 
      method="post"
      name="adminForm">
<div id="editcell">
<table class="adminlist">
<thead><tr>
<th width="5">
<?php echo JText::_( 'NUM' ); ?>
</th>
<th width="20">
<input  type="checkbox" 
        name="toggle" 
        value="" 
        onclick="checkAll(<?php  
           echo count( $this->items ); ?>);" />
</th>
<th class="title">
<?php echo JHTML::_('grid.sort', 'Auto', 'a.text', 
      @$lists['order_Dir'], @$this->lists['order'] ); 
?>
</th>
<th width="5%" align="center">
<?php echo JHTML::_('grid.sort','Published', 
   'a.published', @$this->lists['order_Dir'], 
    @$this->lists['order'] ); ?>
</th>
<th width="1%" nowrap="nowrap">
<?php echo JHTML::_('grid.sort', 'ID', 'a.id', 
    @$this->lists['order_Dir'],
    @$this->lists['order'] ); ?></th>
</tr>
</thead>
<?php
$k = 0;
for ($i=0, $n=count($this->items); $i < $n; $i++){
  $row = &$this->items[$i];
  $published = JHTML::_('grid.published', $row, $i );
  $link = JRoute::_(
    'index.php?option=com_auto&controller=auto&task=edit&cid[]='. 
    $row->id );
  ?>
  <tr class="<?php echo "row$k"; ?>">
  <td></td>
  <td></td>
  <td>
  <a href="<?php echo $link; ?>">
  <?php echo   $row->text; ?></a>
  </td>
  <td align="center"><?php echo $published;?></td>
  <td align="center"><?php echo $row->id;   ?></td>
  </tr>
  <?php 
  $k = 1 -   $k;
}
?>
</table>
</div>
<input type="hidden" name="option" value="com_auto" />
<input type="hidden" name="task"   value="" />
<input type="hidden" name="boxchecked" value="0" />
<input type="hidden" name="controller" value="auto"   />
</form> 

Listing 15.15: /administration/components/views/autos/tmpl/default.php

Dieses Template besteht aus eher »schlichtem« HTML, eingepackt in ein Formular. Es sorgt für die Darstellung der Tabelle (Abbildung 15.13).

Abbildung 15.13: Tabelle der Autos

View Formular (/administration/components/views/auto/view.html.php)

Auch die Einzelansicht der Autos muss geregelt werden. Achten Sie auf den Namen des Unterverzeichnisses. Hier befinden wir uns im Ordner Auto, die Liste ist im Ordner Autos angesiedelt (Listing 15.16).

<?php
defined('_JEXEC')   or die();
jimport( 'joomla.application.component.view' );
class   AutosViewAuto extends JView{
  function display($tpl = null){
    $auto =& $this->get('Data');
    $isNew =   ($auto->id < 1);
    $text = $isNew 
            ? JText::_( 'New' )
            : JText::_( 'Edit' );
    JToolBarHelper::title(JText::_( 'Auto'   ).': 
            <small>[ ' . $text.' ]</small>' );
    JToolBarHelper::save();
    if ($isNew)  {
      JToolBarHelper::cancel();
    }
    else {
      JToolBarHelper::cancel(   'cancel', 'Close' );
    }
    $this->assignRef('auto', $auto);
    parent::display($tpl);
  }
}

Listing 15.16: /administration/components/views/auto/view.html.php

Im Listing wird die Toolbar für die Einzelansicht aufgebaut (Abbildung 15.14). Dieser View ist verwendbar für das Hinzufügen und das Ändern von Datensätzen. In der Variable $isNew wird zwischen beiden Fällen unterschieden.

Abbildung 15.14: Toolbar für das Formular

Template Formular (/administration/components/views/auto/tmpl/form.php)

In diesem Standard-Template wird das Formular für die Einzelansicht aufgebaut (Listing 15.17)

<?php 
defined('_JEXEC') 
or die('Restricted access'); ?>
<script language="javascript"
        type="text/javascript">
... Eingabeüberprüfung ...
</script>
<form action="index.php" 
      method="post" 
      name="adminForm"
      id="adminForm">
<div>
<fieldset class="adminform">
<legend>
  <?php echo   JText::_( 'Details' ); ?>
</legend>
<table class="admintable">
<tr>
<td width="110" class="key">
<label for="title">
  <?php echo JText::_( 'Text' ); ?>:
</label>
</td>
<td>
<input class="inputbox" 
       type="text" 
       name="text"
       id="text"
       size="60"
       value="<?php 
      echo $this->auto->text; ?>"   />
</td>
</tr>
<tr>
...   weitere Felder ...
</tr>
<tr>
<td width="120" class="key">
<?php echo JText::_( 'Published' ); ?>:
</td>
</tr>
</table>
</fieldset>
</div>
<div class="clr"></div>
<input type="hidden"   
       name="option" 
       value="com_auto" />
<input type="hidden" 
       name="id" value="<?php echo $this->auto->id; ?>" />
<input type="hidden"   
       name="task" value="" />
<input type="hidden" 
       name="controller" value="auto"   />
</form>

Listing 15.17: /administration/components/views/auto/tmpl/form.php

Das Formular besteht wieder aus reinem HTML mit PHP-Variablen ($this->auto->id) und statischen Klassenaufrufen (JText). Das Ergebnis sehen Sie in Abbildung 15.15.

Abbildung 15.15: Auto-Datensatz – Änderungsformular

Tabelle auto (/administration/components/tables/auto.php)

Last, but not least, hier die Tabellen-Klasse. Irgendwie muss das Modell ja wissen, mit welchen Daten es eigentlich zu tun hat. Die JTable-Klasse erleichtert den Zugriff und das Verändern von Daten ungemein. Sie ist eine abstrakte Klasse (ein Interface), die es abgeleiteten Klassen ermöglicht, mit ihren Methoden die Struktur zu benutzen. Im Konstruktor werden der Tabellenname und der Primärschlüssel angegeben (Listing 15.18).

<?php
defined('_JEXEC') or die('Restricted access');
class TableAuto extends JTable{
  var $id = 0;
  var $text = '';
  var $hersteller =   '';
  var $photo_klein = '';
  var $photo_gross = '';
  var $published =   0;
  function TableAuto(& $db)   {
    parent::__construct('#__auto',   'id', $db);
  }
}
?>

Listing 15.18: /administration/components/tables/auto.php

Installation (/administration/components/install.sql) und Deinstallation (/administration/components/uninstall.sql)

Bei der Installation/Deinstallation muss der Joomla!-Installer die benötigten Tabellen und Datensätze anlegen bzw. löschen. Hierzu werden zwei Dateien mitgegeben (Listing 15.19 und 15.20):

DROP TABLE IF EXISTS `#__auto`;

CREATE TABLE `#__auto` (
  `id`   int(11) NOT NULL auto_increment,
  `text` text character set utf8 NOT NULL,
  `hersteller` varchar(100) character set utf8 NOT NULL,
  `photo_gross` varchar(200) character set utf8 NOT NULL,
  `photo_klein` varchar(200) character set utf8 NOT NULL,
  `published` tinyint(1) NOT NULL,
   PRIMARY KEY  (`id`)
   )
   ENGINE=MyISAM  AUTO_INCREMENT=5 ;

INSERT INTO `#__auto` (`id`, `text`, `hersteller`, 
         `photo_gross`, `photo_klein`, `published`)
  VALUES
  (2, 'Smart fortwo', 'Smart',  
'http://localhost/joomla150/images/stories/com_auto/smart_gross.jpg',
'http://localhost/joomla150/images/stories/com_auto/smart_klein.jpg',
  1),
  (4, 'Roadster', 'Smart',
'http://localhost/joomla150/images/stories/com_auto/roadster_gross.jpg',
'http://localhost/joomla150/images/stories/com_auto/roadster_klein.jpg',
  1);

Listing 15.19: /administration/components/install.sql

DROP TABLE IF EXISTS `#__auto`;

Listing 15.20: administration/components/uninstall.sql

15.2.4 Test

Nachdem Sie alle Dateien durchgesehen haben, können Sie die Komponente testen und die Datensätze komplett über die Joomla!-Administration verwalten. Sie können neue Texte anlegen, vorhandene löschen, ändern und veröffentlichen. Durch ein vorheriges Ankreuzen der Einträge können Sie beim Veröffentlichen bzw. beim Löschen mehrere Einträge auf einmal bearbeiten. Versuchen Sie ein paar Dinge zu verändern und zu erweitern. Es ist gar nicht so schwer.

15.2.5 Installationspaket erstellen

Um ein Installationspaket für Ihre neue Komponente zu schnüren, benötigen Sie außer den beschriebenen Tabellen noch die obligatorische XML-Datei mit den Metadaten.

auto.xml

Hier beschreiben Sie Ihre neue Komponente gegenüber dem Joomla!-Installer. Sie müssen alle Informationen wie Metadaten und alle Dateinamen in XML-Tags einschließen. Der Joomla!-Installer liest diese Datei aus, erzeugt neue Unterverzeichnisse, kopiert die Dateien an den richtigen Platz und legt die benötigten Tabellen an (Listing 15.21).

<?xml   version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM 
  "http://dev.joomla.org/xml/1.5/component-install.dtd">
<install type="component" version="1.5.0">
<name>Auto</name>
<creationDate>November 2007</creationDate>
<author>Hagen Graf</author>
<authorEmail>hagen.graf@gmail.com</authorEmail>
<authorUrl>http://www.cocoate.com</authorUrl>
<copyright>All rights reserved</copyright>
<license>GNU/GPL</license>
<version>Component Version String</version>
<description>Beschreibung der Komponente ...</description>
<files folder="site">
  <filename>index.html</filename>
  <filename>auto.php</filename>
  <filename>controller.php</filename>
  <filename>views/index.html</filename>
  <filename>views/auto/index.html</filename>
  <filename>views/auto/view.html.php</filename>
  <filename>views/auto/tmpl/index.html</filename>
  <filename>views/auto/tmpl/default.php</filename>
  <filename>models/auto.php</filename>
</files>
<install>
<sql>
  <file charset="utf8" driver="mysql">install.sql</file>
</sql>
</install>
<uninstall>
<sql>
  <file charset="utf8" driver="mysql">uninstall.sql</file>
</sql>
</uninstall>
<administration>
 <menu>Joomla! 1.5 Buch Auto</menu>
 <files folder="admin">
   <filename>index.html</filename>
   <filename>admin.auto.php</filename>
   <filename>controller.php</filename>
   <filename>controllers/auto.php</filename>
   <filename>controllers/index.html</filename>
   <filename>models/auto.php</filename>
   <filename>models/autos.php</filename>
   <filename>models/index.html</filename>
   <filename>views/autos/view.html.php</filename>
   <filename>views/autos/index.html</filename>
   <filename>views/autos/tmpl/default.php</filename>
   <filename>views/autos/tmpl/index.html</filename>
   <filename>views/auto/view.html.php</filename>
   <filename>views/auto/tmpl/form.php</filename>
   <filename>views/auto/index.html</filename>
   <filename>views/auto/tmpl/index.html</filename>
   <filename>tables/auto.php</filename>
   <filename>tables/index.html</filename>
   <filename>install.sql</filename>
   <filename>uninstall.sql</filename>
 </files>
</administration>
</install>

Listing 15.21: auto.xml

Um das Installationspaket zu erzeugen, müssen Sie alle erstellten Dateien in ein Verzeichnis kopieren und dieses Verzeichnis zu einem ZIP-Paket mit dem Namen der Komponente, in unserem Fall com_auto.zip, verpacken. Die Dateien für das Frontend kommen in einen Ordner site, die für den Administrationsbereich in einen Ordner admin (Abbildung 15.16).

Abbildung 15.16: Dateien der Komponente com_auto

Die zip-Datei können Sie jetzt mit dem Joomla!-Installer wie gewohnt installieren und, wenn Sie wollen, zum Download für andere Anwender bereitstellen. Bevor Sie das in Ihrer eigenen Installation tun, sollten Sie die per Hand erstellte Variante über den Joomla!- Installer deinstallieren. Klicken Sie dazu auf Erweiterungen - Installieren/Deinstallieren, markieren Sie Ihre Komponente und klicken Sie auf das Icon Deinstallieren.

Um Joomla! lokal auf Ihrem PC installieren zu können, müssen Sie eine Serverumgebung, wie oben beschrieben, bereitstellen.

Windows

Windows ist sehr benutzerfreundlich und weit verbreitet. Über 90% aller PC arbeiten mit Windows als Betriebssystem. Windows XP und Windows Vista sind die vorherrschenden Varianten. Leider sind weder der Webserver Apache⁵ noch die Datenbank MySQL⁶, geschweige denn PHP⁷ im Lieferumfang enthalten.

Sie können jedes dieser Programme einzeln installieren, Sie können allerdings auch auf ein vorkonfiguriertes Paket zurückgreifen. Das schont die Nerven und ist sehr praktisch.

In Windows XP und Windows Vista sollten Sie sich auf Ihrem System im Administratormodus anmelden. Falls Sie nicht wissen, ob Sie Administratorrechte haben, sehen Sie in Start - Systemsteuerung - Benutzerkonten nach und ändern Sie die Rechte gegebenenfalls (Abbildung 2.1.1). In Windows Vista finden Sie die Einstellung unter Start - Systemsteuerung - Benutzerkonten und Jugendschutz.

Abbildung 2.1.1: Benutzerkonten in WinXP

XAMPP für Windows

XAMPP ist ein Projekt von Kai Seidler und Kay Vogelgesang. Die beiden »backen« seit mehreren Jahren eine komplette Serverumgebung mit den Zutaten Apache, MySQL, PHP, Perl und diversen sinnvollen Erweiterungen und stellen sie auf ihrer Website⁷ als ZIP-Archiv für gängige Betriebssysteme zur Verfügung. Das ist von immensem Vorteil für Menschen wie Sie und mich, da wir ja in erster Linie an Joomla! interessiert sind und nicht so sehr daran, wie das Drumherum funktioniert. Außerdem kann man die ganze Installation mit einem Mausklick wieder rückstandsfrei vom Windows-PC entfernen. Zur Deinstallation löschen Sie genau einen Ordner.

Aber bevor Sie es löschen, müssen Sie es zunächst installieren:

Laden Sie sich die Datei xampplite-win32-1.6.4.exe von der Buch-CD oder der Website⁸.

Abbildung 2.1.2: Extrahieren auf D:

Durch einen Doppelklick auf die Datei packt sich das Archiv aus (Abbildung 2.1.2). Sie können direkt auf ein Laufwerk Ihrer Wahl auspacken. Es entsteht ein Verzeichnis xampplite (Abbildung 2.1.3).

Abbildung 2.1.3: Windows Explorer in Windows Vista Home Premium

Doppelklicken Sie auf die Datei xampp-control.exe im xampplite-Verzeichnis und starten Sie Apache und MySQL. PHP wird dabei als Apache-Modul mitgestartet (Abbildung 2.1.4). XAMPP nimmt keine Einträge in die Windows-Registry vor und setzt auch keine Systemvariablen.

Abbildung 2.1.4: xampp-control.exe ausführen

Es kann sein, dass die Windows Firewall anspringt und entrüstet feststellt, dass Sie zwei Server gestartet haben, und fragt, ob Sie das wirklich wollen. Klicken Sie auf Nicht mehr blocken (Abbildung 2.1.5). Danach müssen Sie unter Windows Vista noch einmal explizit auf Fortfahren klicken.

Abbildung 2.1.5: Warnhinweise der Firewall unter Windows Vista

Öffnen Sie Ihren Internetbrowser und geben Sie http://127.0.0.1/ oder http://localhost/ ein. Danach sollten Sie die XAMPP-Startseite sehen. Klicken Sie auf den Link deutsch, und es zeigt sich folgende Seite (Abbildung 2.1.6):

Abbildung 2.1.6: Startseite XAMPP für Windows

Das Dokumentenverzeichnis für Ihre Website ist

[Laufwerk]:\xampplite\htdocs

In diesem Verzeichnis liegen alle von einem anderen Rechner im Internet zugänglichen Dateien. Lesen Sie die beigelegte readme_de.txt-Datei von XAMPP lite zu Ihrer Sicherheit aufmerksam durch. Dort finden Sie auch weitere Informationen zu den evtl. benötigten benötigten Passwörtern.

Wenn Sie das Paket deinstallieren wollen, stoppen Sie alle laufenden Server und löschen Sie einfach das xampplite-Verzeichnis.

Linux

Bei Linux liegen die Dinge meist einfacher. Es gibt verschiedene Distributionen mit verschiedenen Standardkonfigurationen. Meist ist unser Dreamteam vorinstalliert und muss nur gestartet werden. Es besteht auch die Möglichkeit, eine XAMPP-Version für Linux zu installieren. Meines Erachtens ist es hier allerdings sinnvoller, auf die Originalprogramme zurückzugreifen. Die Installation erfolgt mittels Paketmanager und ist sehr einfach.

OpenSUSE > 10.x

Mithilfe des Konfigurationsprogramms YaST2 können Sie überprüfen, ob Apache, MySQL und PHP bereits installiert sind. Sollte das nicht der Fall sein, wählen Sie die entsprechenden Pakete zur Installation aus und lassen Sie sie durch YaST2 installieren.

Im Einzelnen handelt es sich um die Pakete:

• apache2, apache2-devel, apache2-mod_php5

• mysql, php5-mysql

Sie finden diese Pakete über die Oberfläche von YaST (Abbildung 2.1.7) auf den Datenträgern Ihrer SUSE-Distribution oder auf speziellen Paketseiten im Internet⁹.

Abbildung 2.1.7: YaST, von einem Windows-PC aus in einer Shell aufgerufen

Starten Sie den Webserver Apache durch den Befehl:

/etc/init.d/apache2 start

Starten Sie den Datenbankserver MySQL dann über:

/etc/init.d/mysql start

Stoppen können Sie beide mit dem Parameter stop. Eine Übersicht über alle Parameter erhalten Sie mit help.

Debian/Ubuntu

Bei Debian und auch Ubuntu heißt das Mittel der Wahl apt. Mithilfe des Programms apt können Sie Apache, MySQL und PHP installieren.

apt-get install [paketname]

Im Einzelnen handelt es sich um die Pakete:

• apache-common – Support files for all Apache webservers

• php5 – A server-side, HTML-embedded scripting language

• mysql-common – mysql database common files (/etc/mysql/my.cnf)

• mysql-server – mysql database server binaries

Sie finden diese Pakete automatisch über apt im Internet oder auf der Debian-CD/DVD.

Starten Sie Apache dann durch den Befehl /etc/init.d/apache2 start und MySQL über /etc/init.d/mysql start.

Eigener Server bei einem Provider (Root Server)

Wenn Sie einen kompletten Server bei einem Provider gemietet haben, so haben Sie meist einen Shell-Zugang und die freie Wahl der Linux-Distribution, die Sie benutzen wollen. Außerdem ist das System vorkonfiguriert und enthält bereits alle notwendigen Dateipakete und Konfigurationen. Für die Konfiguration dieser Server werden meist spezielle Administrationsoberflächen wie Confixx¹⁰ oder Plesk¹¹ benutzt. Mit diesen Tools können Sie Ihren Server und die Dienste Apache und MySQL bequem über eine Browseroberfläche starten, stoppen und konfigurieren.

Joomla! benötigt:

• einen installierten und funktionierenden Webserver, z.B. Apache ab Version 1.13.19 oder Microsoft IIS.

• die Skriptsprache PHP ab Version PHP 4.3. Die Unterstützung für MySQL und Zlib muss in PHP einkompiliert sein. Zlib ist eine Bibliothek, die es PHP ermöglicht, Dateipakete zu lesen, die mit dem ZIP-Verfahren komprimiert wurden.

• das Datenbanksystem MySQL ab Version 3.23.x, bei Unicode-Zeichensätzen MySQL ab 4.1.x.