Erstellung eines Web-basierten Konfigurators für Renn - Lab4Inf ...

Fachhochschule Münster
Fachbereich Elektrotechnik und Informatik
Diplomarbeit
Erstellung eines Web-basierten Konfigurators für
Renn- und Triathlonräder mittels PHP und MySQL
von
Marco Ressler
Betreuer/Prüfer:
Prof. Dr. rer. nat. Nikolaus Wulff
Dipl.-Kfm. Christian Pyrrek

Eidesstattliche Erklärung
Ich versichere hiermit, dass ich diese Diplomarbeit ohne fremde Hilfe selbstständig
verfasst und nur die angegebenen Quellen und Hilfsmittel benutzt habe. Wörtlich
oder dem Sinn nach aus anderen Werken entnommene Stellen sind unter Angabe
der Quelle kenntlich gemacht.
Die Arbeit wurde bisher in gleicher oder ähnlicher Form keiner anderen Prüfungsbehörde
vorgelegt und auch nicht veröffentlicht.
Münster, den 22.Juli 2006

Inhaltsverzeichnis
Einführung
V
1 PHP vs. Java 1
1.1 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Die Vor- und Nachteile bei Java und JSP . . . . . . . . . . . 3
1.1.2 Anwendungsbereiche von Java . . . . . . . . . . . . . . . . . 4
1.2 PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Die Vor- und Nachteile bei PHP . . . . . . . . . . . . . . . . 6
1.2.2 Typische Anwendungen bei PHP . . . . . . . . . . . . . . . 7
1.3 PHP vs. Java - überhaupt vergleichbar? . . . . . . . . . . . . . . . 7
2 Das Renn-/Triathlonrad 10
2.1 Aufbau und Komponenten . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Abhängigkeiten der Komponenten . . . . . . . . . . . . . . . . . . . 14
3 Das Programm aus Sicht des Nutzers 19
3.1 Programmablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Bildschirmausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.1 Navigationsleiste . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2.2 Komponententabelle . . . . . . . . . . . . . . . . . . . . . . 22
3.2.3 Übersichtstabelle . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.4 Sonstige Anzeigen . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.5 Showroom . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Diplomarbeit
I

INHALTSVERZEICHNIS
4 MySQL Datenbank 27
4.1 Aufbau der Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.1 Gemeinsame Eigenschaften . . . . . . . . . . . . . . . . . . . 28
4.1.2 Einzelne Tabellen . . . . . . . . . . . . . . . . . . . . . . . . 29
5 Die Progamm-Dateien 35
5.1 Programmablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2 Darstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.1 index.php . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.2.2 Main.php . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.2.3 Showroom.php . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.3 XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3.1 XML-Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3.2 XML-Handler Klasse . . . . . . . . . . . . . . . . . . . . . . 46
5.4 Event-Handler Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4.1 Die Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.2 Weitere Funktionen . . . . . . . . . . . . . . . . . . . . . . . 50
6 Das Programm aus Sicht des Entwicklers 53
6.1 Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.1.1 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.1.2 Entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.1.3 Auswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.1.4 Zusätzliche Auswahl . . . . . . . . . . . . . . . . . . . . . . 56
6.1.5 Reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.2 Komponentenklassen . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.2.1 Funktion set session . . . . . . . . . . . . . . . . . . . . . . 59
6.2.2 Funktion display . . . . . . . . . . . . . . . . . . . . . . . . 61
6.2.3 Weitere Funktionen . . . . . . . . . . . . . . . . . . . . . . . 63
6.3 Elternklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
6.3.1 Komponentendarstellung . . . . . . . . . . . . . . . . . . . . 65
6.3.2 Komponenten entfernen . . . . . . . . . . . . . . . . . . . . 68
6.3.3 Preis- und Gewichtsaktualisierung . . . . . . . . . . . . . . . 69
Diplomarbeit
II

INHALTSVERZEICHNIS
6.4 Weitere Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.4.1 XML Handler Klasse . . . . . . . . . . . . . . . . . . . . . . 70
6.4.2 Session Handler Klasse . . . . . . . . . . . . . . . . . . . . . 72
6.4.3 Datenbank Handler Klasse . . . . . . . . . . . . . . . . . . . 72
6.5 Interaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.5.1 Event: Navigation . . . . . . . . . . . . . . . . . . . . . . . . 73
6.5.2 Event: Auswahl . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.5.3 Event: Auswahl mit Zusatz . . . . . . . . . . . . . . . . . . 77
7 Zusammenfassung und Ausblick 79
7.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
7.3 Schlusswort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
A Tables der Datenbank 83
B Screenshots 91
Quellenverzeichnis 94
Diplomarbeit
III

Abbildungsverzeichnis
2.1 Übersicht Fahrrad-Komponenten . . . . . . . . . . . . . . . . . . . 11
3.1 Pfade im Programmablauf . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Navigatonsleiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3 Komponententabelle . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Übersichtstabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.1 Aufbau der Artikelnummer . . . . . . . . . . . . . . . . . . . . . . . 29
5.1 Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2 Diagramm zur index.php . . . . . . . . . . . . . . . . . . . . . . . . 41
6.1 Aufteilung zwischen Footer und Head . . . . . . . . . . . . . . . . . 66
6.2 Ablauf beim Event Navigation . . . . . . . . . . . . . . . . . . . . . 75
6.3 Ablauf beim Event Auswahl . . . . . . . . . . . . . . . . . . . . . . 76
6.4 Ablauf beim Event zusätzliche Auswahl . . . . . . . . . . . . . . . . 78
B.1 Die Startseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
B.2 Konfigurator für Triathlonräder . . . . . . . . . . . . . . . . . . . . 92
B.3 Konfigurator für Rennräder . . . . . . . . . . . . . . . . . . . . . . 93
Diplomarbeit
IV

Einführung
Das Ziel dieser Arbeit war es mit Hilfe von kostengünstigen Mitteln einen Webbasierten
Konfigurator für Renn- und Triathlonräder zu erstellen. Um die Entwicklungskosten
zu minimieren wurden die Skriptsprache PHP und die open-source Datenbank
MySQL gewählt. In Auftrag gegeben wurde das Projekt won der Firma
all4triathlon.com, einem Internethandel, der sich auf die Nischensportart Triathlon
spezialisiert hat. Eine Recherche im Internet hat ergeben, dass viele schon vorhandene
Konfiguratoren für z. B. Rennräder sehr unzureichend sind [NR05] oder nur
eine Marke unterstützen [Bik06]. Dieser Umstand sollte mit diesem Konfigurator
geändert werden, so dass ein benutzerfreundliches Programm unabhängig von Herstellern
existiert.
Mit Hilfe des Konfigurators kann sich ein Benutzer, unter Berücksichtigung der
Abhängigkeiten der einzelnen Komponenten, sein Wunsch-Fahrrad“ erstellen. Diese
Abhängigkeiten galt es in PHP zu realisieren, in dem eine so genannte Rule- ”
”
Engine“ entworfen wurde, so dass am Ende ein Rennrad erstellt wird, bei dem die
einzelnen Teile sich auch tatsächlich von einem Mechaniker zusammenbauen lassen.
Zusätzlich mussten nicht nur die komponentenspezifischen Daten gespeichert und
dargestellt werden, sondern es sollten auch der Preis und das Gewicht automatisch
berechnet werden. Eine weitere Anforderung an den Prototypen war, dass, nachdem
ein Rad zusammengestellt war, es möglich sein sollte ein oder mehr weitere
Räder zu konfigurieren. In einer Gesamtübersicht sollten dann alle erstellten Räder
angezeigt werden, so dass man die Gelegenheit hat alle Rennräder miteinander zu
vergleichen.
Der fertige Prototyp ist unter der Internetadresse http://www.radtraum.de
erreichbar.
Diplomarbeit
V

Kapitel 1
PHP vs. Java
Am Anfang er Entwicklung stellte sich natürlich die Frage mit welchen Mitteln der
Konfigurator erstellt werden sollte. Manche Programmiersprachen schieden von
vornherein aus. Dazu gehören z. B. C/C++, Delphi oder Pascal. Unter anderem
weil die Sprachen nicht für Webanwendungen zu verwenden sind. Am Ende kamen
nur Java bzw. JSP 1 oder PHP in Frage. Beide (Skript-)Sprachen sind hervorragend
geeignet für Anwendungen im Internet und ebenso können beiden Sprachen den
Anforderungen des Konfigurators gerecht werden.
In diesem Kapitel soll auf die Eigenschaften und auf die Vor-/Nachteile der jeweiligen
Sprache eingegangen werden. Auch werden typische Anwendungen von Java
und PHP vorgestellt. Gegen Ende des Kapitels wird ein Resümee gezogen, wobei
sich von vornherein die Frage stellt, ob sich diese Sprachen überhaupt vergleichen
lassen.
1.1 Java
Angefangen hat die Entwicklung von Java im Jahre 1991 unter dem Namen Green ”
Project“. Ursprünglich war eine komplette Betriebssystemumgebung geplant und
1992 gab es die erste funktionsfähige Anwendung, in der mittels Touchscreen und
1 Java Server Pages
Diplomarbeit 1

KAPITEL 1. PHP VS. JAVA
GUI 2 mehrere Geräte interaktiv gesteuert werden konnten. Das bevorzugte Betätigungsfeld
sollte aber das immer populärere Internet werden. Im Jahre 1995 wurde
dann Java erstmals offiziell der Öffentlichkeit vorgestellt. Mit der Kooperation
zwischen Netscape und Sun kam der Durchbruch für Java. Die erste Version, also
Java 1.0, wurde dann 1996 veröffentlicht. Es waren zwar noch nicht viele Pakete
enthalten, was sich aber mit der Version 1.1 aus dem Jahre 1997 änderte. Damals
wurden heute selbstverständliche Funktionen, wie JavaBeans oder JDBC 3 zum Zugriff
auf Datenbanken, erstmals implementiert. Mit der ein Jahr später erschienen
Version 1.2 änderte sich der Name in Java 2. So hießen die Produkte nicht mehr
JDK1.2 sondern J2SDK 4 . Eine herausragende Neuerung in dieser Version war ein
so genannter Just-in-Time Compiler, so dass Java-Programme deutlich schneller
liefen als vorher. Hinzu kamen noch verschiede Änderungen an den Standard-
Bibliotheken. Im Jahr 2000 kam die nächste Version auf den Markt, bei dem neben
einer erweiterten API 5 auch weitere Optimierungsroutinen implementiert wurden.
Nach zwei weiteren Jahren erschien die Version 1.4, in welcher erneut Änderungen
an der Programmiersprache selbst vorgenommen wurden. Zuletzt geschah dies in
Version 1.1. Implementiert wurden auch Erweiterungen die eine Serverprogrammierung
vereinfachen sollten, wie z. B. mit JSPs. Die momentan (Stand Juli 2006)
aktuelle Version ist 1.5, in der unter anderem generische Typen oder weitere Hilfsklassen
eingeführt wurden. Die Version wurde aber wieder umbenannt und heißt
nun Java 5.0 [Wik06a].
So weit der Überblick der Geschichte von Java. Doch warum sollte ein Entwickler
überhaupt Java oder Java Server Pages wählen? Die üblichen Vorteile, die immer
wieder genannt werden, sind z. B. die Portabilität und die Vielseitigkeit der Sprache.
Nachfolgend werden die Vor- und Nachteile von Java, JSP usw. hervorgehoben
und analysiert.
2 Graphical User Interface
3 Java DataBase Connectivity
4 Java 2 Software Development Kit
5 Application Programming Interface
Diplomarbeit 2

KAPITEL 1. PHP VS. JAVA
1.1.1 Die Vor- und Nachteile bei Java und JSP
Zum Anfang eine Eigenschaft von Java,, welche noch immer im Internet zu lesen,
jedoch mittlerweile überholt ist. Es wird oft genannt, dass Java eine clientseitige
Sprache sei [Ind06]. Z. B. durch JSP ist Java heute eher eine serverseitige Sprache
geworden.
Den größten Vorteil, den Java besitzt ist die Plattformunabhängigkeit. So ist ein
einmal kompilierter Code auf jedem System einsetzbar, dass die JVM installiert
hat. Dies wird auch als write once, run everywhere“ umschrieben. Aber durch die
”
Java Virtual Machine ergeben sich auch Nachteile. Es muss eine JVM erst einmal
auf dem System vorhanden sein, damit der Java-Code läuft. Als großer Vorteil
wird bei Java immer wieder die Skalierbarkeit angeführt. Skalierbarkeit bedeutet,
dass eine Anwendung problemlos auf größere Rechnersysteme übertragen werden
kann, wenn es die Benutzerzahlen bzw. die Systembelastung erfordert. So kann ein
Javaprogramm ohne weitere Optimierung viele Aufgaben bewältigen, so lange die
Hardware stimmt [Hom06b].
Der nächste Vorteil ist die Testbarkeit von Programmen. Dieses wird häufig durch
Komponentenmodelle wie EJB erreicht. Da diese Enterprise Java Beans
unabhängig voneinander Aufgaben erfüllen können, werden diese Funktionen üblicherweise
auch getrennt getestet, so dass das Aufspüren von Fehlern leichter ist
[Ihn06]. Dieser Vorteil wird seit PHP4, und besonders seit PHP5, aufgehoben, da
objektorientiertes Programmieren nun auch dort möglich ist. Wobei man allerdings
sehr viel mehr Disziplin“ beim Erstellen des Codes haben muss, um die gleiche
”
Testbarkeit und Modularität von Java zu erreichen.
Das führt direkt zu einem weitern Vorteil bzw. Nachteil, je nach Sichtweise: Bei
Java ist Vieles von vornherein definiert und abstrahiert. So müssen bei Java Variablentypen
und Klassen deklariert werden, oder es müssen Referenztypen angegeben
werden um objektorientiert zu arbeiten. Das bringt aber auch Typensicherheit. Außerdem
muss Java über eine main-Funktion verfügen damit der Java-Interpreter
einen so genannten Startpunkt hat.
Falls eine komplette Entwicklungsumgebung mit dazugehörigem Server gekauft,
bzw. gemietet werden soll, so sind die Kosten üblicherweise nicht gering. Eine
Diplomarbeit 3

KAPITEL 1. PHP VS. JAVA
einzige Benutzerlizenz für Sun Java Studio Enterprise 7 kostet schon 1.850 e; eine
Verlängerung der Lizenz kostet nochmals 1.300 e 6 . Für eine Java-Application-
Server Software wird jährlich nochmals 1.950 e 7 verlangt [Cat06]. Allein an diesen
Preisdimensionen kann man sofort sehen, dass dies ein großer Nachteil von Java ist,
und sich entweder nur für gut situierte Unternehmen und/oder große Anwendungen
eignet.
Ein weiterer Nachteil mag in dem relativ schweren Erlernen der Programmiersprache
liegen. Auch die strikte Objektorientierung mag für manchen Anfänger
zu abstrakt erscheinen. Weiterhin wird als Nachteil die längere Anlaufzeit“ eines
”
Java-Projekts genannt. Wie lange allerdings die Gesamtentwicklungszeit einer Anwendung
dauert, kommt natürlich auf das Projekt an. Dabei heißt es, dass je größer
die Anwendung, desto kürzer ist die Entwicklungszeit gegenüber PHP [XF04].
1.1.2 Anwendungsbereiche von Java
Hauptsächlich wird Java in E-Business Anwendungen eingesetzt. Auch auf Webund
Applikationsservern wird Java in diesem Bereich verwendet. Die J2EE bietet
hierfür einen modularen Aufbau und die Möglichkeit mehrschichtige Anwendungen
zu erstellen. Das Spektrum reicht hier von Call-Center Lösungen über Kundeninformationssystemen
bis hin zu graphischen Editoren [ID06].
Applets sind bzw. waren ein wichtiges Aufgabengebiet von Java. Gegen Ende der
neunziger Jahre war ein Java-Chatraum, das eigentlich eine Applet war, Normalität.
Andere Anwendungen fanden sich in der Datenpräsentation, in Animationen
und Visualisierungen. Heute sind Applets nicht mehr so verbreitet, werden aber
immer noch gerne zu Visualisierungszwecken in Wissenschaft und Technik benutzt.
Heutzutage findet man Java auch in kleinen, mobilen Geräten wie einen PDA
oder das Mobiltelefon. Hier können dann verschiedenste Anwendungen, vom Spiel
bis zum Fahrplan 8 , ausgeführt werden. Allerdings wird nur das Notwendigste der
6 jeweils ohne MWSt.
7 ohne MWSt.
8 siehe www.mofahr.de
Diplomarbeit 4

KAPITEL 1. PHP VS. JAVA
JVM implementiert - die kleinste Version der J2ME, CLDC genannt [Hom06a],
verzichtet sogar auf Berechnung von Fließkommazahlen.
1.2 PHP
PHP ist als Programmiersprache relativ jung. Erst 1995 wurde sie aus einer Sammlung
Perl-Skripten erschaffen. Der Name stand damals noch für Personal Home
”
Page“. 1997 wurde dann PHP 2.0 veröffentlicht, in dem ein Form Interpreter beinhaltet
war. Deshalb wurde auch von PHP/FI gesprochen. Es war Perl recht ähnlich,
wenn auch eingeschränkter und einfacher.
PHP3 wurde neu geschrieben, da die alten Versionen dem e-commerce nicht mehr
genügten. Es erschien 1998. Die Entwicklung des Form Interpreters wurde bald
darauf eingestellt. Es wurde die Firma Zend Technologies gegründet und somit
wurde 2000 die Zend-Engine, die das Herzstück von PHP4 darstellte veröffentlicht,
in der auch einfache objektorientierte Programmierung möglich war. Auch
die Bedeutung der Abkürzung wurde geändert. PHP steht nun für ein rekursives
Akronym und heißt PHP: Hypertext Processor. Der nächste Meilenstein für
diese Sprache kam 2004, als PHP5 veröffentlicht wurde. Nun war ernsthafte OO-
Programmierung möglich, und es kamen Java-ähnliche Funktionen wie Exceptions
vor. Die aktuellste Version ist derzeit 5.1. [Wik06b] [Bra05]
Vor allem das gegen Ende der neunziger Jahre stark anwachsende World Wide
Web verlangte nach einer Skriptsprache, die fähig ist, dynamische Webseiten darzustellen.
Die damals als Standard geltende Sprache Perl wurde von PHP in der
Popularität überholt, da sie als einfacher zu erlernen gilt.
PHP ist eine serverseitige Skriptsprache und wird fast ausschließlich für Webanwendungen
angewandt. Natürlich ist auch ein Zugriff auf Datenbanken, insbesondere
MySQL, möglich. Gerne werden die Vorzüge von PHP genannt: leichte Erlernbarkeit,
schnellere Performance oder einfachstes Zusammenspiel mit HTML.
Nachstehend werden die Vor- und auch die Nachteile einer PHP-basierten Anwendung
beschrieben.
Diplomarbeit 5

KAPITEL 1. PHP VS. JAVA
1.2.1 Die Vor- und Nachteile bei PHP
Der größte Vorteil ist wohl, dass PHP über die GPL 9 vertrieben wird. Das bedeutet,
es ist freie Software. Der Quelltext kann von jedem eingesehen werden, und
daher ist eine GPL-Software auch kostenlos. Ebenso ist MySQL eine freie Software
und kann kostenfrei heruntergeladen werden. Dadurch werden für PHP-Projekte
gegenüber Java weniger Geldmittel aufgewendet werden müssen [Bra05].
Der nächste positive Aspekt von PHP liegt in dem von vornherein großen Funktionsumfang,
wie z. B. optimierte Funktionen zu Datenbankanbindungen, Netzwerken
oder (seit PHP5) XML. Diese stehen sofort zur Verfügung, ohne dass die
Funktionen/Bibliotheken erst importiert oder inkludiert werden müssen. Dadurch
kann sich auch die Entwicklungszeit eines Projekts verkürzen, da viele dieser Funktionen
nicht erst selbst erstellt werden brauchen [Mor02b].
Ein häufig genannter Vorteil ist die Performancegeschwindigkeit, die viel höher
liegen soll als die von Java. Allerdings gibt es in der Praxis zu viele Faktoren, wie
z. B. die Leistungsfähigkeit des Server-Computers und die des Client-Rechners, um
einen Unterschied festzustellen.
Die im Java-Teil schon erwähnte, strenge Typisierung entfällt bei PHP völlig. So
braucht man Variablen nicht deklarieren, denn die erste Zuweisung bestimmt den
Typ. Auch kann man, z. B. bei einer switch-Anweisung, fast jeden Typ verwenden
[Hat02]. Doch dadurch geht auch die Typensicherheit verloren und macht Javatypische
Funktionen wie Polymorphie unmöglich.
Nachteile ergeben sich durch den erhöhten Netzwerktraffic. Da PHP serverseitig
funktioniert, müssen bei jeder zu prüfenden Eingabe diese Daten an den Server
gesendet werden. Diese können durch JavaScript zwar minimiert werden, doch das
ist umständlich und stellt auch nur eine Vorprüfung“ dar [Mor02a].
”
Ein ganz großer Nachteil (insbesondere für größere Projekte) dürfte in der fehlenden
Modularität liegen. Java ist von vornherein auf mehrschichtige Anwendungen
abgestimmt, während man bei PHP schon recht disziplinierter“ arbeiten muss,
” 9 General Public Licence
Diplomarbeit 6

KAPITEL 1. PHP VS. JAVA
um alle Aufgaben sauber von einander zu trennen. Dieses reduziert die Übersichtlichkeit,
die Wartbarkeit und den Wiederverwendungswert [WC04].
1.2.2 Typische Anwendungen bei PHP
Es gibt im Grunde genommen nur einen Anwendungsbereich von PHP, und das
sind dynamische Webseiten, bei denen Daten aus einer Datenbank entnommen
werden.
Aber da das Web viele Anwendungsmöglichkeiten bietet, sind auch die Bereiche in
denen PHP verwendet wird sehr unterschiedlich. Der oben genannte, grundlegende
Prozess kann mitunter auch sehr Komplex werden. Das einfachste Beispiel wäre
eine Homepage eines Hobbyprogrammierers. Das kann bei einem selbst erstellten
Gästebuch oder einem Forum anfangen. Das Ganze kann bis zu einer Unternehmenspräsenz
mit Homepage, e-commerce-shop [osC06] und Content Management
System (CMS) [Typ06] gehen.
Aber es gibt auch neben dem Internet Anwendungsgebiete für PHP. Allerdings
sind diese recht unbedeutend, da es für diese Aufgaben bessere Programmiersprachen
gibt (z. B. Java). Es handelt sich beispielsweise hierbei um Kommandozeilen-
Skripte für häufig verwendete Aufgaben, wobei nur der PHP Interpreter benötigt
wird. Ein weiteres Beispiel ist die clientseitige GUI-Programmierung. Dazu wird
allerdings die Erweiterung PHP-GTK 10 verwendet [Gle03].
1.3 PHP vs. Java - überhaupt vergleichbar?
Auf einer Seite im Internet wird behauptet ein Vergleich zwischen Java und PHP
sei wie ein Vergleich zwischen Coke und Pepsi“ oder Hulk Hogan und Mr. T“
” ”
[Nor03]. Trotz dieser zugegebenermaßen seltsamen Analogie ist es wahr, dass sich
diese beiden Sprachen nicht ohne weiteres Vergleichen lassen. Jede Programmiersprache
hat seine Vor- und Nachteile. Deshalb könnte eigentlich diese Diskussion
damit abgeschlossen werden, indem behauptet wird:
10 GIMP (GNU Image Manipulation Program) Tool Kit
Diplomarbeit 7

KAPITEL 1. PHP VS. JAVA
Grundsätzlich bestimmen die Anforderungen des Kunden welches System
zu Einsatz kommt.[Con04]
Doch welches System kommt wann zum Einsatz? Im Grunde genommen kann
man sagen, dass je größer und umfangreicher eine Anwendung wird, desto eher
sollte Java die Sprache der Wahl sein. Als Beispiel kann man das System eines
Call-Centers nutzen. Dort müssen viele Informationen von tausenden von Kunden
verfügbar sein. Diese Informationen müssen von jedem Call-Center Mitarbeiter
manipulierbar sein, und zusätzlich muss es nachvollziehbar sein, welcher Arbeiter
welche Änderungen vorgenommen hat. Dies ist ein System, das hunderte bis tausende
von Anfragen pro Minute hat und eine riesige Datenbank verwalten muss.
Dabei kann Java z. B. auch die Verteilung der Anrufe steuern. Das Ganze muss
auch so automatisch, d.h. so effizient wie möglich erfolgen.
Die Skriptsprache PHP wäre dabei überfordert, da unter anderem PHP ein so
genanntes Multithread System (mit dem Apache-Server) ist, während Java ein
Multiprocess System darstellt und somit mehrere Aufgaben gleichzeitig erledigen
kann. Außerdem ist es mit PHP nicht möglich auf so genannte Low-Level Ressourcen
zuzugreifen, so dass keine Hardware gesteuert werden kann.
Anders herum ist natürlich PHP vorzuziehen. Besonders bei kleineren oder mittleren
Projekten ist die Entwicklungszeit sehr kurz. Es macht keinen Sinn ein Javasystem
für eine Homepage oder einfache Internetpräsenz eines Unternehmens zu
nutzen. Auch bei etwas größeren Projekten, wie eine e-commerce Applikation oder
ein Content Management System, wäre PHP geeigneter wergen den geringeren
Kosten und der (wahrscheinlich) kürzeren Entwicklungszeit.
Als Fazit der Gegenüberstellung der beiden doch recht unterschiedlichen Programmiersprachen
kann man sagen:
Obwohl PHP schneller erste Fortschritte erzielt, ist bei großen Anwendungen eher
damit zu rechnen, dass die Java-Version schneller fertig gestellt wird. Deshalb ist,
wie schon erwähnt bei großen und umfangreichen Projekten Java zu bevorzugen.
Im Umkehrschluss heißt es also, dass bei kleineren und mittleren Projekten, bei
denen nicht so viel Performance benötigt wird, PHP vorzuziehen ist.
Diplomarbeit 8

KAPITEL 1. PHP VS. JAVA
Für das Projekt mit der Erstellung des Konfigurators stand dann fest, dass PHP
verwendet werden sollte. Die Webanwendung ist nicht so umfangreich, dass ein
Team von Programmierern zur Realisierung benötigt wäre. Ebenso wäre eine derart
teure Anschaffung, wie die einer Lizenz für Java Studio Enterprise 7, für dieses
Projekt kaum gerechtfertigt.
Diplomarbeit 9

Kapitel 2
Das Renn-/Triathlonrad
Ein Renn- bzw. Triathlonrad besteht aus vielen Komponenten, die nicht beliebig
austauschbar sind. Es stand früh fest, dass dies ein interdisziplinäres Projekt werden
würde. Nicht nur Programmierfähigkeiten waren notwendig, sondern auch ein
technisches und mechanisches Verständnis für den Aufbau einer solchen Rennmaschine“.
Daher bestand ein nicht unerheblicher Teil dieser Diplomarbeit daraus,
”
zu ermitteln, welche Komponenten bzw. Komponentengruppen sich überhaupt für
einen Konfigurator eignen.
Als Beispiel kann das Laufrad genannt werden: es besteht aus Felge, Speichen, Nabe
und Schnellspanner. Jedes dieser Teile ließe sich einzeln kaufen und so könnte
man nur für das Laufrad vier weitere Bauteile in den Konfigurator aufnehmen. Dieses
detailgenaue Erstellen eines Rennrades würde allerdings den Rahmen sprengen,
und so mussten Bauteilgruppen zusammengefasst werden 11 um eine überschaubare
Menge an Komponenten zu erhalten.
Der nächste zeitaufwändige Teil bestand darin, zu ermitteln, in welchen Abhängigkeiten
diese Komponenten zueinander standen, bzw. wie diese Bauteile zusammengebaut
werden. Unter anderem wurden bei unterschiedlichen Herstellern unterschiedliche
Bezeichnungen verwendet, so dass erst herausgefunden werden musste,
welche dieser Bezeichnungen das Gleiche bedeuteten. Als Beispiel kann man die
Größe der Laufräder verwenden, denn dort gibt es drei Bezeichnungen für den
11 Die Komponenten Kurbelsatz und Schaltgruppe bestehen ebenfalls aus mehreren Einzelteilen
Diplomarbeit 10

KAPITEL 2. DAS RENN-/TRIATHLONRAD
gleichen Durchmesser: normal ist ein Durchmesser von 28 ”. Die Bezeichnung von
Reifen- und Schlauchherstellern lautet hier für 663, was diese Größe in mm angibt,
während die traditionelle französische Bezeichnung 700C ist, und oft von
Laufradherstellern verwendet wird.
Abbildung 2.1: Übersicht Fahrrad-Komponenten
2.1 Aufbau und Komponenten
An diesem Punkt sind die Komponenten aufgelistet, die in dem Konfigurator Verwendung
finden. Da die Benutzung ein gewisses Vorwissen über den Aufbau eines
Rennrades erfordert, das die Zielgruppe zweifellos besitzt, werden die einzelnen
Baugruppen beschrieben, und es wird erklärt was deren Funktionen sind. Abbildung
2.1 zeigt wo an einem Rennrad die Komponenten zu finden sind.
Diplomarbeit 11

KAPITEL 2. DAS RENN-/TRIATHLONRAD
Rahmen Der Rahmen ist das Herzstück des Fahrrades, da fast alle anderen Bauteile
daran angebaut werden. An dieser Komponente werden direkt der Steuersatz,
die Gabel, die Sattelstütze und der Kurbelsatz befestigt. Eine wichtige
Einheit bei der Auswahl eines Rahmens ist die Rahmenhöhe.
Steuersatz Diese Komponente hält Gabel und Rahmen zusammen und sorgt mit
den Kugellagern dafür, dass diese auch beweglich bleibt. Der untere Teil des
Steuersatzes wird auf die Gabel geschoben, und diese beiden Bauteile werden
dann durch das Steuerrohr des Rahmens geschoben. Mit dem oberen Teil des
Steuersatzes wird dann die Gabel an das Rohr festgeklemmt.
Gabel An der Gabel werden am oberen Ende der Vorbau, der Lenker und (beim
Triathlonrad bzw. Zeitfahrrad) der Aeroaufsatz montiert. Am unteren Ende
wird das vordere Rad befestigt. Die Gabel wird, wie schon beschrieben, mit
Hilfe des Steuersatzes an das Steuerrohr des Rahmens befestigt.
Vorbau Der Vorbau ist das Verbindungsstück zwischen Gabel und Lenker. Er
wird in verschiedenen Längen gefertigt, die individuell vom Fahrer ausgewählt
werden. Ein Vorbau kann auch einen bestimmten Winkel besitzen, damit der
Lenker eine für den Fahrer optimale Höhe erreichen kann.
Lenker Der Lenker ist an dem Vorbau befestigt, und er kann verschiedene Breiten
von 40 cm bis 44 cm haben. Diese muss von Fahrer individuell gewählt werden.
An dem Lenker sind bei einem Rennrad die Schalt-Bremshebel befestigt
(Die Schaltung und die Bremse befinden sich in einem Bauteil).
Aeroaufsatz Dieses Bauteil wird nur bei Zeit- bzw. Triathlonrädern verwendet.
Durch den Aufsatz wird eine aerodynamischere Fahrposition erreicht. Hier
befinden sich die Schalthebel am Ende es Aufsatzes, während sich die Bremsen
am Lenker befinden.
Laufräder Die Laufräder sind ein für die Aerodynamik wichtiges Bauteil. Sie
können je nach Einsatzzweck normale Speichen und Felgen, (für normale
Radrennen), oder besonders aerodynamisch Geformte, bis hin zu einer Scheibe
am Hinterrad (für Zeitfahren u. ä.) haben. Bei speziell für Aerodynamik
Diplomarbeit 12

KAPITEL 2. DAS RENN-/TRIATHLONRAD
und Gewicht ausgerichtete Laufräder spricht man auch von Systemrädern.
Zusätzlich wird zwischen Schlauch- und Drahtreifen unterschieden. Auch gibt
es zwei verschiedene Arten von Naben am hinteren Laufrad, die mit dem
Hersteller für die Schaltgruppe kompatibel sein müssen.
Reifen Den Kontakt zum Boden bilden die Reifen. Es gibt spezielle Gummi-
Mischungen für Wettkampf und Training. Außerdem wird zwischen Schlauchreifen
und Drahtreifen unterschieden. Erstere werden wie normale Reifen
gehandhabt, während letztere aufwändig auf das Laufrad geklebt werden.
Kurbelsatz Dies ist eine Bauteilgruppe, die aus sehr vielen Einzelteilen besteht,
die, wenn sie einzeln zusammengestellt werden sollten, den Umfang eines
Konfigurators sprengen würden. Doch viele Hersteller bieten Komplettsysteme
an. Ein Kurbelsatz besteht aus zwei bzw. drei Kettenblättern, zwei Kurbeln,
einer Achse und dazu passendes Tretlagergehäuse samt Kugellager. Die
Kurbeln werden in verschiedenen Längen angeboten, die entsprechend den
Vorlieben des Fahrers ausgewählt werden.
Schaltgruppe Hier gibt es nur zwei weltweit führende Hersteller, Shimano und
Campagnolo, deren Systeme untereinander nicht kompatibel sind. Auch die
Schaltgruppe besteht aus vielen Einzelteilen, wie z. B. einem vorderen und
hinteren Umwerfer, der für das Wechseln der Kette auf die verschiedenen
Ritzel bzw. Kettenblätter zuständig ist. Des weiteren gehört zu einer Schaltgruppe
ein Ritzelpaket, auch Kassette genannt. Es besteht aus neun bis zehn
unterschiedlich großen Ritzeln, die auf die hintere Nabe des Laufrades gesteckt
werden. Ein weiteres Bauteil ist der so genannte Käfig, der dafür
sorgt, dass die Kette stets gespannt bleibt. Zur Schaltgruppe gehören auch
die Schalt-Bremshebel.
Bremsen Mit den Bremsen ist der tatsächliche Bremskörper gemeint. Die Bremsbacken
greifen an der Felge des Laufrades und verlangsamen so die Fahrt.
Pedale Die Pedale werden an das Ende der Kurbeln vom Kurbelsatz geschraubt.
Sie sind üblicherweise so genannte Klick-Pedale, mit denen dann der Radschuh
fest an der Pedale befestigt ist. Das hat den Vorteil, dass nicht nur Vor-
Diplomarbeit 13

KAPITEL 2. DAS RENN-/TRIATHLONRAD
triebskraft beim Herunterdrücken der Pedale ausgeübt wird, sondern zusätzlich
auch beim Hochziehen Vortrieb geleistet wird, da die Schuhe mit den
Pedale fest verbunden sind.
Sattelstütze Eine Sattelstütze ist nicht nur notwendig um einen Sattel zu befestigen,
sondern sie sollte auch entsprechend der individuellen Körpergröße des
Fahrers verstellbar sein. Da die Stütze dem Fahrtwind ausgesetzt ist, werden
oft aerodynamische Ansprüche an diese Komponente gestellt.
Sattel Auf dem Sattel sitzt der Fahrer die meiste Zeit, und ist somit optimal
auf die menschliche Anatomie ausgerichtet. Es gibt sogar spezielle Sättel für
Männer und Frauen, sowie je nach Fahrstil ausgerichtete Sättel.
2.2 Abhängigkeiten der Komponenten
In diesem Abschnitt werden die Abhängigkeiten der Komponenten untereinander
aufgezählt bzw. welche Größen mit welchen Komponenten zusammenpassen. Auch
hier gilt, dass ein gewisses Vorwissen von Namen und Bezeichnungen vorhanden
sein sollte. Abbildung 2.1 kann dabei eine Hilfe sein.
Rahmen An einen Rahmen werden viele weitere Bauteile angebracht. Weil der
Rahmen die zentrale Komponente ist, sind viele andere Elemente von den
Maßen des Rahmens abhängig. So gibt es verschiedene Größen für das Steuerrohr,
das Tretlager, die Sattelstütze, und – je nach Rahmenhöhe 12 – die
Laufräder.
Das Steuerrohr kann einen Durchmesser von 1 ” oder 1 1 /8 ” haben. Das wirkt
sich dann auf den Steuersatz, die Gabel und den Vorbau aus. Die Sattelstütze
kann verschiedenste Maße zwischen 26 mm und 34 mm Durchmesser annehmen.
Auch das Tretlager, das zum Kurbelsatz gehört, kann zwei unterschiedliche
Maße haben: ITA (metrisch, 70 mm Durchmesser) und BSA (imperial,
12 Die Rahmenhöhe leitet sich von der Schritthöhe des Fahrers ab.
Diplomarbeit 14

KAPITEL 2. DAS RENN-/TRIATHLONRAD
68 mm Durchmesser), um die traditionellen Größen-Bezeichnungen zu benutzen.
Zuletzt hängen auch noch die Durchmesser der Laufräder, und damit
auch die Größe bzw. Länge der Gabel, von dem Rahmen ab, denn unter
einer Rahmenhöhe von 52 cm werden üblicherweise 26 ” anstatt 28 ” Räder
verwendet.
Steuersatz Hier ist es wichtig welche Größe das Steuerrohr des Rahmens, und
somit der Gabelschaftdurchmesser hat. Beträgt das Maß nur 1 ” können nur
Steuersätze mit dem gleichen Maß verwendet werden. Bei 1 1 /8 ” verhält es
sich genau so.
Gabel Bei dieser Komponente sind zwei Maße wichtig: der Gabelschaftdurchmesser
und ob die Gabel für 26 ” oder 28 ” Räder geeignet ist. Beides ergibt sich
aus der Rahmengeometrie, d.h. zum einen der Durchmesser des Steuerrohrs
und zum anderen die Rahmenhöhe.
Vorbau Der Vorbau hat drei Maße, die zu beachten sind, wobei eine zwar wichtig
für den Fahrer ist, aber unerheblich für den Konfigurator. Es handelt sich
hierbei um die Länge des Vorbaus. Diese ist je nach Vorlieben und Körpergröße
des Fahrers unterschiedlich.
Eines der beiden Maße, die für das Programm von Bedeutung sind, wäre
der Durchmesser für das Loch, das auf den Gabelschaft montiert wird. Diese
Größe hängt, wie der Steuersatz und die Gabel selber auch, von dem Durchmesser
des Steuerrohrs am Rahmen ab. Hier gibt es die schon genannten
Maße 1 ” und 1 1 /8 ”.
An der anderen Seite des Vorbaus ist die Öffnung, an die der Lenker festgeklemmt
wird. Hier werden die Maße wieder in Millimeter angegeben. Üblich
sind 26.0 mm und 31.8 mm als Lenkerrohrdurchmesser. Je nach dem welche
Größe dieser Durchmesser bei dem ausgewählten Vorbau hat, werden bei der
Komponente Lenker nur die entsprechenden Artikel angezeigt.
Lenker Wie oben erwähnt, sind die Lenkerrohrdurchmesser 26.0 mm und 31.8 mm
üblich. Diese Maße sind auch später für den Aeroaufsatz wichtig, falls ein
Triathlonrad gewählt wurde. Es sind noch andere Informationen über den
Lenker von Bedeutung. So muss z. B. angegeben sein, ob dieser Lenker nicht
Diplomarbeit 15

KAPITEL 2. DAS RENN-/TRIATHLONRAD
schon vom Hersteller aus über einen Aeroaufsatz verfügt. Diese Art Lenker
dürfen dann nicht angezeigt werden wenn ein Rennrad konfiguriert werden
soll. Es kann auch vorkommen, dass ein Lenker nicht dafür geeignet ist, einen
zusätzlichen Aeroaufsatz aufzunehmen. Dies muss auch berücksichtigt werden,
und somit dürften diese Lenker nicht bei einem Triathlonrad angezeigt
werden.
Aeroaufsatz Diese Komponente steht nur zur Auswahl, wenn der Nutzer ein
Rennrad konfigurieren möchte. Der Aeroaufsatz ist natürlich von den Vorgaben
des Lenkers abhängig. Da der Aufsatz normalerweise auf den Lenker
geklemmt wird, ist der Lenkerrohrdurchmesser hier von entscheidender Bedeutung.
Allerdings bieten manche Hersteller so genannte Multi-Fit Systeme
an, die bei (fast) allen Lenkern passen. Dies muss im Konfigurator ebenfalls
berücksichtigt werden.
Des Weiteren kann es vorkommen, dass ein Lenker schon vom Hersteller aus
einen Aeroaufsatz fest montiert hat. Auch das ist ein Aspekt, der berücksichtigt
werden muss.
Laufräder Hier sind ebenso zwei übliche Maße zu beachten. Zum einen gibt es
die 28 ” und die 26 ” Räder. Die Größe ist indirekt von der Körpergröße
abhängig, denn diese bestimmt die Rahmenhöhe. Unterschreitet die Höhe
einen bestimmten Betrag (üblich sind 52 cm), so werden automatisch im
Konfigurator die kleineren Reifen gewählt. Zusätzlich gibt es noch, wie oben
beschrieben, den Unterschied zwischen Draht- und Schlauchreifen. Diese Information
ist für die Komponente Reifen wichtig.
Eine weitere Eigenschaft, die später bei der Schaltgruppe und/oder dem Kurbelsatz
wichtig wird, ist die Nabe des hinteren Laufrades. Auf diese Nabe
wird die so genannte Kassette aufgesteckt, die aus bis zu zehn Kettenblättern
besteht. Es gibt nur zwei marktbeherrschende Hersteller für Schaltgruppen
im Radsport: Shimano und Campagnolo. Die Naben sind nicht untereinander
kompatibel. Daher muss auch auf diese Eigenschaft beim Konfigurator
geachtet werden.
Diplomarbeit 16

KAPITEL 2. DAS RENN-/TRIATHLONRAD
Reifen Die einzige Abhängigkeit, die hier besteht, ist der Unterschied zwischen
den Schlauch- und Drahtreifen. Sie bestimmt welche Art der Reifen dargestellt
wird. Eine weitere, aber für den Konfigurator nicht relevante Größe
sind die Breite der Reifen.
Kurbelsatz Bei der Vorauswahl eines Kurbelsatzes ist nicht nur zu beachten, dass
die Tretlager dieser Komponente auch in das Tretlagergehäuse des Rahmens
passen müssen. Es ist auch noch im Konfigurator zu prüfen, ob nicht schon
die Laufräder gewählt wurden, und somit die Anzeige der Komponenten nicht
weiter eingeschränkt wird. Abgesehen von der Kurbellänge, bestimmen die
weiteren Maße und Eigenschaften eines Kurbelsatzes, welche Schaltgruppe
später zur Auswahl steht.
Da wäre die Art und Anzahl der Kettenblätter. Es gibt drei Variationen: die
normale Ausführung mit zwei Blättern, die compact“ Version, mit ebenfalls
”
zwei Kettenblättern, aber kleinerem Durchmesser und weniger Zähnen, und
die Variante mit drei Blättern. Die Anzahl der Zähne auf den Kettenblättern
ist wichtig um die so genannte Kapazität des Schaltkäfigs bei der Schaltgruppe
zu berechnen. Außerdem sind manche Schaltgruppen speziell auf compact
oder dreifach-Antriebe ausgerichtet.
Eine weitere Abhängigkeit besteht bei der Marke der Schaltgruppe. Da es
nur die Marken Shimano oder Campagnolo gibt, und die einzelnen Teile nur
bedingt bis gar nicht kompatibel untereinander sind, werden z. B. durch die
Wahl eines Shimano-Kurbelsatzes auch nur Shimano-Komponenten bei der
Kategorie Schaltgruppen angezeigt. Es gibt aber auch Anbieter von Kurbelsätzen,
bei denen es möglich ist, Schaltgruppen von beiden Herstellern zu
benutzten. Dies alles muss natürlich im Konfigurator berücksichtigt werden.
Schaltgruppe Die Anzeige der Schaltgruppenkomponenten wird entweder durch
die Wahl der Laufräder oder durch die Wahl des Kurbelsatzes eingeschränkt.
Außerdem bewirkt die Berechnung der Kapazität der Kette eine weitere Vorauswahl.
Andere Daten von vorherigen Komponenten dienen für die spätere
Montage des Rades, und nicht mehr für die Funktionalität des Konfigurators.
Weitere gespeicherte Eigenschaften der Schaltgruppe dienen noch zu
Darstellungszwecken.
Diplomarbeit 17

KAPITEL 2. DAS RENN-/TRIATHLONRAD
Bremsen Hier gibt es keine Abhängigkeiten und keine Vorauswahl der Komponenten.
Es kann sogar eine Campagnolo Bremse an ein Rad mit Shimano-
Schaltgruppe montiert werden.
Pedale Bei den Pedalen gibt es ebenfalls keine Abhängigkeiten mit anderen Bauteilen.
Jede Pedale passt an jede Kurbel. Es gibt aber noch verschiedene
Pedalsysteme 13 , die nur mit bestimmten Radschuhen kompatibel sind. Die
sind allerdings nicht relevant für den Konfigurator – das muss der Nutzer
selbst entscheiden, was für ein System er verwenden möchte.
Sattelstütze Das einzige Maß auf das hierbei geachtet werden muss, ist der
Durchmesser der Sattelrohraufnahme beim Rahmen. Weitere Eigenschaften,
wie z. B. die Länge der Sattelstütze dienen nur zu Darstellungszwecken und
sind nicht weiter relevant für die Vorauswahl von anderen Bauteilen.
Sattel Auch hier gibt es keine Abhängigkeiten mit anderen Komponenten, denn
auf jeder Sattelstütze lässt sich ein beliebiger Sattel montieren.
13 Es gibt das so genannte Look-System und die SPD-Pedale von Shimano
Diplomarbeit 18

Kapitel 3
Das Programm aus Sicht des
Nutzers
3.1 Programmablauf
Der Ablauf vom Zusammenstellen eines Rennrades sollte recht flexibel sein. Es
wurde überlegt, welche Art von Nutzerführung am sinnvollsten erscheint. Zur Auswahl
standen der so genannte Wizard-Mode“, in dem jede Komponente einzeln
”
und nacheinander durchgegangen wird, bis alle Bauteile ausgewählt sind. Dem gegenüber
stand die freie Wahl der Reihenfolge, in der der Nutzer die Komponenten
wählen kann. Natürlich ist wegen der Abhängigkeiten untereinander keine gänzlich
freie Wahl möglich, aber in einem gewissen Rahmen ließe sich das realisieren.
Für die assistierte Zusammenstellung sprach die relativ einfache Programmierung,
aber auf der anderen Seite würde sich ein Nutzer zu sehr in seiner Wahlfreiheit
eingeschränkt fühlen. Denn die Zielgruppe ist der schon fortgeschrittene Fahrer,
der die einzelnen Komponenten an seinem Rad kennt, und der sich durch einen
Assistenten-Modus eher bevormundet“ fühlen würde. Außerdem wäre der ganze
”
Prozess des Konfigurierens nicht sehr transparent.
Für die (relativ) freie Wahl sprach eine bessere Benutzerfreundlichkeit, wie z. B.
die Möglichkeit eine schon ausgewählte Komponente schnell zu entfernen, ohne
Diplomarbeit 19

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
einige Male einen Zurück-Button im Wizard-Mode“ anzuklicken. Ein weiterer
”
Vorteil ist, dass durch eine Navigationsleiste die Übersicht behalten wird, und alles
innerhalb einer Webseite passieren kann. Der große Nachteil war allerdings die
komplizierte Implementierung und die ganzen Möglichkeiten, die sich dadurch einem
Nutzer ergeben, abzufangen und in die gewünschten Bahnen zurückzulenken.
Ein Beispiel hierfür wäre, dass der Nutzer nach der Wahl des Rahmens nicht sofort
den Lenker wählen kann. Er könnte zwar in der Navigationsleiste auf die Rubrik
Lenker klicken, aber durch entsprechende Mitteilungen müsste der Nutzer wieder
die geforderte Reihenfolge einhalten.
Abbildung 3.1: Pfade im Programmablauf
Diplomarbeit 20

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
Schließlich wurde wegen der genannten Vorteile die freie Wahl implementiert. Der
Nutzer kann zwar nicht in beliebiger Reihenfolge die Komponenten wählen, aber
er kann so genannte Pfade entlang die Rad-Elemente aussuchen. Die Bauteile in
den Pfaden sind unabhängig von einander, so dass nur innerhalb dieser Pfade der
Nutzer auf eine bestimmte Reihenfolge in der Auswahl gebracht wird. Als Beispiel
(siehe Abb. 3.1) wären der Pfad im Konfigurator mit den Komponenten Laufräder
und Reifen, und der Pfad mit Sattelstütze und Sattel. Die Komponenten dieser
Pfade sind unabhängig voneinander, während z. B. die Reifen von den Laufrädern
abhängig sind, und der Sattel erst nach der Sattelstütze gewählt werden kann.
3.2 Bildschirmausgabe
In den folgenden Sektionen wird auf die einzelnen Elemente, die auf dem Bildschirm
sichtbar sind, eingegangen und erklärt welche Funktion sie haben. Die meisten Elemente
dienen dazu den Konfigurator zu bedienen, wie z. B. die Navigationsleiste
oder die Tabelle mit den Komponenten. Der Rest ist für die Darstellung von Informationen
zuständig. Dazu zählt die Anzeige vom Gesamtpreis, Gewicht oder
ausgewählter Marke.
3.2.1 Navigationsleiste
Die Leiste zum Navigieren ist natürlich sehr wichtig. Ohne sie wäre das Steuern
und Bedienen des Konfigurators unmöglich. Wie schon vorher erwähnt (Seite 19),
ist das das Resultat der Entscheidung gegen einen völlig starren Ablauf im Konfigurieren
eines Rades.
In der Navigationsleiste sind die alle 13 Komponenten aufgelistet. Dies gilt aber
nur für ein Rennrad, denn bei einer Zusammenstellung eines Triathlonrades sind
es 14 Komponenten. Bei einem Rennrad wird die Komponente Aeroaufsatz nicht
verwendet, und daher taucht dieses Element in der Navigationsleiste nicht auf.
Klickt der Nutzer auf eine dieser Kategorien, werden ihm die zur Verfügung stehenden,
und kompatiblen Bauteile in der Komponententabelle angezeigt. Muss vorher
Diplomarbeit 21

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
noch eine andere Komponente gewählt werden, wird eine entsprechende Meldung
dargestellt. Wird ein Artikel gewählt, so färbt sich das Feld dieser Komponente
ein. Dieses dient dazu um dem Nutzer einen Überblick zu verschaffen welche Komponente
er schon gewählt hat, denn bei einer nicht assistierten und freien Wahl
der Bauteile kann die Übersicht schnell verloren gehen. Falls eine Entscheidung
zurückgenommen wird, und die entsprechende Baugruppe entfernt werden soll, so
werden auch in der Navigationsleiste dieses Feld, und alle damit zusammenhängenden
Felder, wieder auf die Ursprungsfarbe zurückgesetzt.
Abbildung 3.2: Navigatonsleiste
3.2.2 Komponententabelle
Auch diese Tabelle ist sehr wichtig. Hier kann der Nutzer die Komponenten anschauen,
auswählen und ggf. löschen. Jedes angezeigte Bauteil ist kompatibel mit
Diplomarbeit 22

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
den vorher ausgewählten Elementen, bzw. mit den angegeben Körpermaßen. Jedes
Element der Komponententabelle ist gleich aufgebaut, unterscheidet sich aber in
den Informationen. So sind in der ersten Zeile die Artikelnummer, der Name der
Komponente und daneben der Preis zu finden. Darunter ist eine Zeile mit einer
kurzen Beschreibung des Produkts und ein kleines Bild zu finden. Die darunter liegende
Zeile findet sich nicht bei jeder Komponente, sondern nur bei denen, die eine
zusätzliche Information brauchen. Als Beispiel kann man die Sattelstütze nennen,
bei dem diese Zeile angibt welchen Durchmesser und welche verstellbare Länge
sie hat 14 . In der letzten Zeile, die wieder für alle Baugruppen gilt, sind dann das
Gewicht und der Auswahl-Button zu finden. Gegebenenfalls erscheint auch hier
eine Schaltfläche zum Entfernen der Komponente.
Abbildung 3.3: Komponententabelle
Eine Abwandlung der Komponententabelle besteht in der so genannten zusätzlichen
Auswahl. Bei den Komponenten Vorbau und Kurbelsatz bieten die Hersteller
das gleiche Produkt in verschiedenen Längen an. Da sonst die Komponententabelle
zu lang und zu unübersichtlich wäre, wenn alle Produkt- und Längenkombinationen
dort aufgelistet wären, wurde diese zusätzliche Auswahl implementiert.
14 In der Abbildung bezieht sich die zusätzliche Info auf die Rahmenhöhe.
Diplomarbeit 23

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
Wählt der Nutzer z. B. einen Vorbau, erscheint automatisch eine weitere Tabelle
an der Stelle, an der auch die Komponententabelle war, und der Nutzer wird
aufgefordert eine passende Länge zu dem Vorbau auszuwählen. Hierbei wird die
Navigationsleiste ausgeblendet, damit der Nutzer erst diese Wahl treffen muss.
Diese Vorgehensweise wäre ein Beispiel für die Lenkung der Entscheidungen des
Nutzers, damit dieser nichts falsch machen“ kann.
”
3.2.3 Übersichtstabelle
Diese Tabelle dient, wie der Name schon aussagt, zur Übersicht. Während der
Nutzer anhand der Navigationsleiste erkennen kann welche Komponenten er schon
gewählt hat, so sind in der Übersichtstabelle genauere Informationen zu finden. In
jeder Zeile der Tabelle ist eine Komponente aufgelistet. In der zweiten Spalte ist der
jeweilige Name des ausgewählten Fahrradelements zu finden. In der dritten Spalte
ist dann noch einmal der Preis der Komponente aufgezeigt. Sollte es vorkommen,
dass z. B. bei dem Rahmen die Gabel schon im Lieferumfang enthalten ist, so wird
dies mit einem entsprechenden Eintrag in der Tabelle bei der Zeile Gabel vermerkt.
Der angegebene Preis wäre dann natürlich 0,00e. Für den Fall, dass ein Rennrad
zusammengestellt werden soll, zeigt die Übersichtstabelle des Konfigurators ein
N/A“ bei der Komponente Aeroaufsatz an, da bei einem Rennrad keine solchen
”
Elemente zum Einsatz kommen.
3.2.4 Sonstige Anzeigen
Zu den sonstigen Anzeigen zählen z. B. der Gesamtpreis und das Gesamtgewicht.
Da beide Angaben für einen Radfahrer sehr wichtige Daten sind, dürfen sie bei
einem Renn- und Triathlonkonfigurator nicht fehlen. Das Feld mit diesen Informationen
ist unter der Übersichtstabelle positioniert. Je nachdem ob eine Komponente
ausgewählt, oder wieder entfernt wird, ändern sich der Preis und das Gewicht
automatisch.
Eine weitere Anzeige ist die der ausgewählten Marke für die Komponente Schaltgruppe.
Diese wird nicht von Anfang an dargestellt, da die Wahl der Marke bei
Diplomarbeit 24

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
Abbildung 3.4: Übersichtstabelle
den Laufrädern, dem Kurbelsatz oder erst bei der Schaltgruppe fällt. Sollten alle
Komponenten, für die die Kompatibilität mit Shimano oder Campagnolo wichtig
ist, entfernt werden, so wird auch diese Anzeige nicht mehr dargestellt. Diese Information
wird ebenfalls unter der Übersichtstabelle angezeigt.
Zu manchen Komponenten wird auch ein Infotext angezeigt, der den Nutzer z. B.
darüber aufklärt aus welchen einzelnen Elementen die Schaltgruppe besteht. Auch
wird darauf hingewiesen, bei welcher Komponente die Schaltgruppenmarke festgelegt
wird. Dieser Infotext ist ebenfalls dynamisch, so dass der eben genannte
Hinweis nur angezeigt wird, wenn die Marke noch nicht gewählt wurde. Die Hinweise
sind an dem unteren Rand des Bildschirms zu finden.
Ein weiterführender Link erscheint über der Navigationsleiste wenn alle Komponenten
gewählt wurden. Dieser Verweis führt den Nutzer zu dem so genannten
Showroom“, in dem er sich bis zu drei selbst erstellte Räder anschauen, und die
”
einzelnen Bauteile, den Gesamtpreis und das Gesamtgewicht vergleichen kann.
Diplomarbeit 25

KAPITEL 3. DAS PROGRAMM AUS SICHT DES NUTZERS
Die letzte, der so genannten sonstigen Anzeigen, ist eine Schaltfläche am oberen
linken Bildschirmrand. Der Knopf dient zum Neustart des aktuell zu konfigurierenden
Rades. Wird dieser angeklickt, so werden alle bisher ausgewählten Komponenten
entfernt. Allerdings kann nur das aktuelle Rad neu konfiguriert werden
– schon fertig zusammengestellte Räder, die im Showroom“ betrachtet wurden,
”
sind nicht mehr löschbar, es sei denn, der Nutzer fängt wieder mit der Startseite
wieder an.
3.2.5 Showroom
Der Showroom ist eine eigene php-Datei. Das heißt, es wird nicht mehr alles von der
Main.php gesteuert. Hier werden das aktuelle Rad und vorher konfigurierte Räder
dargestellt. Diese Seite besteht aus drei Tabellen, die ähnlich der Übersichtstabelle
auf der Hauptseite sind. Es werden hier auch der Komponentenname, der
Artikelname und der Einzelpreis je Komponente nebeneinander angezeigt. Unter
der Tabelle ist dann noch einmal der jeweilige Gesamtpreis und das Gesamtgewicht
dargestellt.
Diese Übersicht ist bisher bei noch keinem der schon im Internet verfügbaren Fahrradkonfiguratoren
vorhanden. So kann der Nutzer von seinem Wunschrad mehrere
Ausführungen oder Ausstattungen erstellen und so auf einen Blick entscheiden,
welche Konfiguration ihm am geeignetsten erscheint.
Es ist möglich bis zu drei Renn- bzw. Triathlonräder zusammenzustellen. Sind
noch nicht alle Räder konfiguriert, so erscheint unter den Tabellen noch ein Link,
der den Nutzer wieder zu der Hauptseite führt. Dort kann dann ein weiteres Rad
erstellt werden. Die Komponentendaten sind natürlich wieder alle gelöscht, so dass
keine Bauteilgruppe ausgewählt ist. Es werden die Daten, die der Nutzer auf der
Startseite angegeben hat, wie Körper- und Schritthöhe, sowie die daraus resultierenden
anderen Maße, beibehalten. Falls andere Körpermaße oder ein anderer
Radtyp gewünscht ist, muss der Nutzer wieder von vorne beginnen.
Diplomarbeit 26

Kapitel 4
MySQL Datenbank
4.1 Aufbau der Tables
Als Datenbank wurde eine normale MySQL Datenbank verwendet, da zumindest
in der Phase eines Prototyps nicht so viele Daten und Benutzerzahlen zusammenkommen,
dass andere, kommerzielle Datenbanksysteme wie Oracle [Ora06] oder
DB2 [IBM06] in Betracht gezogen werden müssten.
Die Datenbank ist der essentielle Teil des Konfigurators, denn darin sind alle relevanten
Daten zu den einzelnen Komponenten gespeichert. Unter relevanten Daten
sind Informationen zur Darstellung innerhalb es Konfigurators, wie z. B. Komponentenname
oder die Beschreibung zu verstehen. Die wichtigeren Daten innerhalb
der Datenbank sind Informationen über die Komponenten, damit die Abhängigkeiten
zwischen anderen Bauteilgruppen erkannt werden können. So ist, um ein
Beispiel zu nennen, im Rahmen-Table der Durchmesser der Gabelaufnahme hinterlegt.
Ebenso ist diese Größe bei jeder Komponente im Gabel-Table erfasst, damit
im Konfigurator nur die Gabeln angezeigt werden, die mit der Gabelaufnahme des
Rahmens zusammenpassen.
Diplomarbeit 27

KAPITEL 4. MYSQL DATENBANK
4.1.1 Gemeinsame Eigenschaften
Da jede Komponente verschiedene Abhängigkeiten mit anderen Rennradteilen besitzt,
hat jedes Table eine unterschiedliche Anzahl von Spalten und Eigenschaften.
Allerdings sind einige Spalten bei allen Tables gleich, da sie unter anderem für die
Darstellung im Konfigurator gebraucht werden. Damit die Daten aus den Spalten
später einfach extrahiert werden können, sind diese immer die Ersten eines Tables
und damit immer an der gleichen Stelle und Reihenfolge.
Es handelt es sich dabei um folgende Spalten:
Artikelnummer Ein eindeutiger Schlüssel, der gleichzeitig auch der Primary Key
ist. Die Artikelnummer besteht aus sechs Zeichen, wovon das erste Zeichen
ein Buchstabe ist, der die Komponente bezeichnet. A‘ wäre in diesem Fall der
’
Rahmen, B‘ der Steuersatz usw. Die nächsten beiden Zeichen bestehen aus
’
Zahlen und stellen einen Code für den Hersteller/die Marke dar. Die nächsten
beiden Ziffern bezeichnen die wievielte Komponente des Herstellers es in der
Datenbank ist. Das letzte Zeichen sollte wieder ein Buchstabe sein, und steht
für verschiedene Ausführungen bei dem gleichen Artikel. Ein Beispiel wäre
hierfür, wenn es einen Lenker in drei verschiedenen Breiten gibt.
Gewicht Hier wird das Gewicht der jeweiligen Artikel eingetragen, da es für einen
Renn- und Triathlonfahrer sehr wichtig ist, wie viel sein Rad wiegt. Der
Eintrag in der Datenbank dient zum Darstellen im Konfigurator und zur
Errechnung des Gesamtgewichts.
Preis Der Betrag, den eine Komponente kostet, wird in dieser Spalte eingetragen.
Auch diese Daten dienen zur Darstellung im Konfigurator und zur Errechnung
des Endpreises.
Name Der Name der Komponente. Dieser Eintrag wird nur zur Darstellung in
dem Konfigurator und der Übersichtstabelle verwendet.
Beschreibung Ein kurzer Text zur Beschreibung der Komponente, in dem für
den Benutzer, aber nicht für die Funktion des Konfigurators, relevante Daten
stehen können.
Diplomarbeit 28

KAPITEL 4. MYSQL DATENBANK
Abbildung 4.1: Aufbau der Artikelnummer
Bild Eine URL zu einem kleinen Bild. Dies dient nur zu Darstellungszwecken. Allerdings
ist diese Funktion im Prototyp nur durch ein Beispiel-Bild realisiert,
das bei jedem Artikel gleich ist. Es wird aber später notwendig sein, dass der
Dateiname des Bildes gleich dem der Artikelnummer (und gleichzeitig auch
des Primary Keys) ist.
Allein durch diese Daten in der Datenbank wäre es möglich den Konfigurator mittels
PHP und HTML darzustellen. Alle zusätzlichen Spalten sind notwendig damit
die Abhängigkeiten zwischen den Komponenten erkannt und die kompatiblen Bauteilgruppen
dargestellt werden können.
4.1.2 Einzelne Tabellen
Die folgende Beschreibung zeigt die einzelnen Tables auf, und gibt eine kurze Erklärung
warum diese Spalte erstellt wurde, und wie/ob sie notwendig für andere
Komponenten ist. (Vgl. Anhang A ab Seite 83)
TABLE Rahmen
Diplomarbeit 29

KAPITEL 4. MYSQL DATENBANK
• rahmenhoehe: das Maß wird aus den auf der Startseite angegebenen Daten
des Benutzers berechnet. Die Rahmen mit der übereinstimmenden Größe
werden angezeigt. Außerdem ist das Maß für die Größe der Laufräder relevant.
• gabelaufnahme: hier ist gespeichert welcher Gabelschaftdurchmesser mit
diesem Rahmen zusammenpassen wird.
• gabelvorhanden: der Wert in dieser Spalte kann nur 0 oder 1 annehmen,
und gibt an ob der Rahmen schon mit einer Gabel ausgeliefert wird.
• steuersatz: ebenfalls können hier nur die Werte 0 und 1 angenommen werden.
Die Spalte gibt an, ob der Steuersatz mit dem Rahmen geliefert wird.
• sattelrohr: gibt an, welcher Durchmesser (in mm) das Rohr für die Sattelstütze
hat. Ist ein Wert über 100 angegeben, impliziert das eine schon
beim Rahmen vorhandene Sattelstütze.
• tretlager: da es hier zwei Standardmaße gibt, ist diese Spalte wichtig um
anzugeben, welche Tretlagergröße der Kurbelsatz haben muss.
TABLE Steuersatz
• gabelschaft: der gespeicherte Wert gibt an zu welchen Gabelschaft- bzw.
Gabelaufnahmegrößen der Steuersatz passt.
TABLE Gabel
• gabelschaft: auch hier wird die Größe des Gabelschafts angegeben, damit
die Gabel auch mit dem Rahmen und dem Steuersatz zusammenpasst.
• laenge: die Größe der Laufräder, also 28 ” oder 26 ”, die an diese Gabel
montiert werden können, sind in dieser Spalte hinterlegt.
Diplomarbeit 30

KAPITEL 4. MYSQL DATENBANK
TABLE Vorbau
• gabelaufnahme: die Spalte gibt ebenso den Durchmesser des Gabelschafts
an, so dass im Konfigurator nur die Vorbauten angezeigt werden, die mit
dem ausgewählten Rahmen bzw. der Gabel zusammenpassen.
• lenkeraufnahme: hier wird der Wert gespeichert, der angibt was für ein
Durchmesser das Lenkerrohr haben muss, damit der Lenker sich an diesem
Vorbau montieren lässt.
• laenge1: die Hersteller von Vorbauten bieten verschiedene Längen an. Hier
wir die kleinste verfügbare Länge gespeichert.
• laenge2: an dieser Spalte wird die nächst-größere Vorbaulänge eingetragen.
• . . .
• laenge9: bis zu neun verschiedene Längen können gespeichert werden, was
aber nicht notwendig ist, da viele Hersteller nur vier oder fünf Vorbaulängen
zur Auswahl haben.
• winkel: gibt an, mit was für einen Winkel der Vorbau von der Gabel abstehen
wird. Das dient zur weiteren Lenker-Erhöhung/Herabsetzung.
• flip: der Wert kann nur 0 oder 1 annehmen und beschreibt ob der Vorbau
um 180 ◦ drehbar ist, so dass der Fahrer zwischen zwei Winkeln wählen kann.
TABLE Lenker
• lenkerdurchm: alle Lenker, die den gleichen Lenkerdurchmesser haben, wie
von dem Vorbau vorgegeben, werden angezeigt.
• breite: individuelle Größe, die sich nach dem Fahrer richtet. Diese Spalte
dient nur zu Darstellungszwecken, und zum späteren Überprüfen, welche
Komponenten ausgewählt wurden.
Diplomarbeit 31

KAPITEL 4. MYSQL DATENBANK
• lenkerart: in dieser Spalte ist festgehalten um was für eine Art Lenker es
sich handelt: reiner Rennradlenker, reiner Triathlonlenker (üblicherweise mit
Aeroaufsatz) oder ob der Lenker mit beiden Fahrradarten kompatibel ist.
• aeroaufsatz: der Inhalt der Spalte beschreibt, ob an dem Lenker ein Aeroaufsatz
angebaut werden kann, ob dies nicht möglich ist, oder ob schon ein
solcher Aufsatz mit dabei ist.
TABLE Aeroaufsatz
• lenkerklemm da der Aeroaufsatz auf den Lenker geklemmt wird, ist es
wichtig zu wissen, für welche Lenkerdurchmesser der Aufsatz passt.
TABLE Laufraeder
• durchmesser: diese wichtige Spalte gibt an welche Größe die Laufräder
haben. Es werden die traditionellen Maße angegeben: 700 (also 700C) für
28 ” Räder, 650 (also 650C) für 26 ” Räder.
• reifenart: hier ist festgehalten ob es sich um Draht- oder Schlauchreifen
handelt.
• nabe: ebenfalls ein wichtiger Wert wird in dieser Spalte angegeben. Hier
ist hinterlegt mit welchem der beiden Hersteller für Schaltgruppen die Nabe
kompatibel ist.
Näheres siehe auch Seite 16.
TABLE Reifen
• durchmesser: in dieser Spalte ist vermerkt für welche Laufraddurchmesser
die Reifen passen. Auch hier wurden die traditionellen Maße angegeben: 700
(C) und 650 (C)
• breite: dieser Wert dient nur zu Darstellungszwecken und beschreibt für
welche Laufradbreiten der Reifen geeignet ist.
Diplomarbeit 32

KAPITEL 4. MYSQL DATENBANK
• reifenart: da es zwei verschiedene Reifensysteme gibt, ist es wichtig die Art
des Reifens festzuhalten.
TABLE Kurbelsatz
• kettenblatt: der hier hinterlegte Wert gibt an wie viele Kettenblätter an der
Kurbel sind, bzw. ob es sich um eine so genannte Compact-Kurbel handelt.
• zaehne vorne: gibt die Anzahl der Zähne auf dem größten Kettenblatt an.
Dieser Wert dient nicht nur zu Darstellungszwecken sondern ist auch wichtig
um die Kapazität“ des Schaltkäfigs bei der Schaltgruppe zu berechnen.
”
• zaehne mitte: dieser Wert ist nur für die Darstellung wichtig, und wird
auch nur mit einem Inhalt versehen falls es sich um ein 3-fach Kettenblatt
handelt.
• zaehne hinten: die Anzahl der Zähne des kleinsten Kettenblattes werden
hier gespeichert. Auch dieser Wert wird später zur Berechnung der Kapazität
benötigt.
• laenge1: gibt an wie lang die Kurbel von der Mitte zu den Pedalen ist.
Die Angabe ist in mm und da die Hersteller normalerweise mehrere Längen
anbieten, wie hier die kleinste verfügbare Größe gespeichert.
• . . .
• laenge7: bis zu sieben verschiedene Längen können eingetragen werden, was
aber meistens nicht notwendig ist, da viele Hersteller nur zwei oder drei
Kurbellängen zur Auswahl haben.
• kompatibel: auch hier ist angegeben, mit welchem der beiden Hersteller
für Schaltgruppen der Kurbelsatz kompatibel ist. Es ist auch möglich, dass
ein Anbieter einen Kurbelsatz anbietet, der für Shimano und Campagnolo
kompatibel ist.
• innenlager: da diese Komponente unter anderem aus einem Innenlager besteht,
für das es zwei Größen gibt, ist es wichtig diesen Wert festzuhalten,
damit nur kompatible Kurbelsätze angezeigt werden.
Diplomarbeit 33

KAPITEL 4. MYSQL DATENBANK
TABLE Schaltgruppe
• kettenblatt: die Anzahl der Kettenblätter des zuvor ausgewählten Kurbelsatzes
ist für die Schaltgruppe in so fern relevant, dass für verschiedene
Kettenblätter verschieden lange Schaltkäfige benötigt werden.
• hersteller: dies gibt an mit welcher Marke die Schaltgruppe kompatibel ist.
• kassette min: die Anzahl der Zähne der kleinsten Scheibe am Ritzel. Ein
notwendiger Wert zur Berechnung der Kapazität“ der Schaltung.
”
• kassette max: hier wird die Anzahl der Zähne der größten Scheibe am
Ritzel angegeben. Das dient auch zur Berechnung der Kapazität“.
”
TABLE Bremsen
• Keine weiteren Spalten notwendig.
TABLE Pedale
• Keine weiteren Spalten notwendig.
TABLE Sattelstuetze
• laenge: ein Wert der nur zu Darstellungszwecken dient.
• durchmesser: diese Angabe ist notwendig, damit Sattelstützen mit dem
richtigen Rohrdurchmesser angezeigt werden.
TABLE Sattel
• Keine weiteren Spalten notwendig.
Diplomarbeit 34

Kapitel 5
Die Progamm-Dateien
5.1 Programmablauf
Zuerst werden die eingegebenen Daten auf der Startseite berechnet und diese dann
abgeschickt. Zuvor werden jedoch mit Hilfe von JavaScript die Angaben überprüft,
ob sie in einem zulässigen Bereich liegen. Nach dem Abschicken des Formulars wird
die Main.php aufgerufen, bei der es sich um die zentrale Datei handelt.
Verschiedene Variablen und Klassen werden initialisiert, damit am Anfang die
Navigationsleiste, die zur Verfügung stehenden Rahmen, die noch nicht ausgefüllte
Übersichtstabelle und auch schon der Preis/Gewicht-Bereich zu sehen sind. Der
gesamte Konfigurator wird über die angeklickten Links, die eigentlich immer so
genannte Submit-Buttons von Formularen sind, gesteuert.
Wird ein solcher Button angeklickt, wird dieses in der Main.php registriert, indem
die entsprechenden Post-Variablen abgefragt werden. Je nachdem welcher Verweis
aktiviert wurde (oder auch: je nach dem welches Ereignis auftritt), ruft die
Main.php eine andere Funktion der EventHandler Klasse auf. Diese Klasse erkennt
bei welcher Komponente des Rennrades der Konfigurator sich gerade befindet, und
aktiviert die zum Event passende Funktion der zugehörigen Komponentenklasse.
In dieser Klasse werden nun die nötigen Session-Variablen gesetzt, bzw. wieder
gelöscht.
Diplomarbeit 35

KAPITEL 5. DIE PROGAMM-DATEIEN
Abbildung 5.1: Klassendiagramm
Diplomarbeit 36

KAPITEL 5. DIE PROGAMM-DATEIEN
Manche Aufgaben, wie z. B. das Darstellen der Tabelle, oder das Entfernen von
Komponenten geschehen in der Eltern-Klasse. In den Komponentenklassen werden
nur die spezifisch für diese Baugruppe notwendigen Aufgaben erledigt. Darunter
fällt das Setzen von Session-Variablen für die eigene und andere Komponenten, das
Herausfiltern von inkompatiblen Bauteilen oder auch das Füllen der Tabelle mit
den spezifischen Daten. Die Eltern-Klasse, bezeichnenderweise ComponentParent
genannt, ist dagegen für Aufgaben zuständig, die allgemein für alle Komponenten
gleich ist. Dazu zählen das schon erwähnte Darstellen der Tabelle und die Remove-
Routine. In dieser Klasse werden auch die Daten für Preis und Gewicht aktualisiert.
So werden die Ereignisse, die die einzelnen Komponenten betreffen, auf den Bildschirm
gebracht. Allerdings ist die EventHandler Klasse noch für mehr zuständig.
Sie stellt die Navigationsleiste, die Übersichtstabelle und den Preis/Gewichts-
Bereich dar; es wird geprüft ob alle Komponenten ausgewählt wurden, damit ein
weiterführender Link zum Showroom erscheint; und es wird der Primary Key aller
ausgewählten Baugruppen der verschiedenen Rennräder in einem zweidimensionalen
Array gespeichert.
5.2 Darstellung
In diesem Abschnitt werden die php Dateien behandelt, die sich mit der Darstellung
des Konfigurators befassen. Hierbei soll es sich um alles handeln, was auf dem
Bildschirm zu sehen ist, wie die Komponententabelle, die Navigationsleiste oder die
Übersichtstabelle. Zwar bringen z. B. die einzelnen Komponentenklassen auch Informationen
auf den Bildschirm, aber deren primäre Funktion ist es die Regeln der
Abhängigkeit zwischen den Komponenten anzuwenden. Die EventHandler Klasse
selbst stellt auch viele Informationen dar. Diese werden aber durch die Main.php
oder Showroom.php aufgerufen.
Diplomarbeit 37

KAPITEL 5. DIE PROGAMM-DATEIEN
5.2.1 index.php
Das ist die erste Seite, die der Nutzer zu sehen bekommt. Hier werden die Informationen
abgefragt, die für den Start des Konfigurators wichtig sind. Notwendige
Angaben sind nur die Körpergröße und die Schritthöhe. Die anderen Angaben
werden mittels JavaScript automatisch berechnet. Die ganze index.php besteht im
Grunde aus JavaScript, bis auf die Initialisierung der Session.
Beim ersten Aufrufen der Seite wird mit dem JavaScript Befehl navigator.
cookieEnabled überprüft, ob der Browser Cookies zulässt. Durch eine if-Abfrage
wird dann bei positivem Ergebnis die eigentliche Seite dargestellt. Sind keine Cookies
erlaubt, wird dieses angezeigt, und ein Link zum erneuten Laden der Seite
bereitgestellt.
Die dargestellte Seite ist ein Formular, das beim Abschicken erst die eingegebenen
Werte überprüft, und ggf. einen Fehler ausgibt. In der CheckFormular() Funktion
werden die Angaben für Körpergröße, Schritthöhe und Rahmenhöhe kontrolliert.
Da alle drei Prüfungen nach dem gleichen Muster ablaufen, hier als Beispiel nur
den Programmcode für die Körpergröße:
var ZahlCheckFlag = 1;
if(document.datainput.height.value == "")
{
alert("Bitte Deine Körpergröße eingeben!");
document.datainput.height.focus();
return false;
}
if(document.datainput.height.value >=221 ||
document.datainput.height.value

KAPITEL 5. DIE PROGAMM-DATEIEN
}
return false;
for(i=0;i "9")
ZahlCheckFlag = -1;
if(ZahlCheckFlag == -1)
{
alert("Körpermaß ist keine Zahl!");
document.datainput.height.focus();
return false;
}
Die erste if-Abfrage testet, ob überhaupt etwas eingeben wurde. Die nächste Abfrage
prüft ob sich der eingebende Wert in einem bestimmten Bereich befindet. In
diesem Beispiel sollte das Körpermaß zwischen 1,30m und 2,21m liegen. Der letzte
Test kontrolliert, ob alle Zeichen auch Zahlen sind, da es wenig Sinn ergibt eine
Köpergröße oder Rahmenhöhe mit Buchstaben zu versehen. Bei jeder Falscheingabe
wird das fehlerhafte Feld mit document.datainput.height.focus() hervorgehoben,
um dem Nutzer die Suche nach diesem Feld zu ersparen.
In der index.php kann der Nutzer auch zwischen Renn- und Triathlonrad wählen.
Dies hat Auswirkungen auf die angezeigte Rahmenhöhe, da dieses Maß beim Triathlonrad
einige Zentimeter kleiner ist. Diese Größe wird auch dynamisch geändert
sobald der Nutzer einen anderen Radio-Button anklickt. Bewerkstelligt wird dies
mit updateFramesize() und ist ebenfalls mit JavaScript realisiert. Diese Funktion
ruft getBikeType() auf, um festzustellen welcher Radio-Button gerade aktiv ist.
Da diese Buttons die ersten beiden Elemente des Formulars sind, ist es mit Hilfe
von der Abfrage if(document.datainput.elements[X].checked) recht einfach
dies herauszufinden. Wobei X entweder 0 für das erste Element oder 1 für das
zweite Element ist. In der Funktion updateFramesize() wird auch updateStem()
Diplomarbeit 39

KAPITEL 5. DIE PROGAMM-DATEIEN
aufgerufen, die schon im Vorfeld die Auswahlmöglichkeiten der Vorbaulänge einschränkt.
5.2.2 Main.php
Diese Datei ist dafür zuständig, dass alle Klassen, weitere Dateien, und die Bildschirmausgabe
verlinkt“ werden. Deshalb auch der Name Main, da diese php-
”
Datei alles zusammenfügt. Hier werden auch die nötigen Klassen eingefügt und
die Anfangsbedingungen initialisiert. Zuerst werden die aus der index.php übergebenen
Daten in Session-Variablen gespeichert, so dass diese für spätere Berechnungen
oder Darstellungen verwendet werden können. Die Initialisierung ist notwendig,
damit der Konfigurator immer einen bestimmten Startpunkt hat. So wird
z. B. durch den folgenden Code die Navigationsvariable auf die erste Komponente
(hier: der Rahmen) gesetzt, wobei es egal ist ob die Main.php von der index-Datei
oder von der Showroom.php aufgerufen wird.
if (!empty ($_POST[’size’]) or empty($_SESSION[’nav’]))
{
$navigation = $xm->get_component_from_xml(1);
$sh->register_session(nav, $navigation);
$ev->navbar;
}
Ein anderes Beispiel wäre, da es möglich ist bis zu drei Fahrräder zu konfigurieren
und anzeigen zu lassen, dass es notwenig ist am Anfang eine Session-Variable zu
initialisieren, welche speichert wie viele Räder schon konfiguriert wurden.
Anderer Code ist dafür zuständig, dass je nach Event eine andere Funktion aus der
EventHandler Klasse zum Einsatz kommt. Da alles auf dem Bildschirm Anklickbare
ein HTML-Formular ist, werden diese Events durch Abfrage der entsprechenden
POST-Variablen erfasst.
In der Main.php werden auch alle anderen Funktionen aufgerufen, die Informationen
auf dem Bildschirm darstellen. Meistens sind diese Funktionen ebenfalls in der
Diplomarbeit 40

KAPITEL 5. DIE PROGAMM-DATEIEN
Abbildung 5.2: Diagramm zur index.php
Diplomarbeit 41

KAPITEL 5. DIE PROGAMM-DATEIEN
EventHandler Klasse untergebracht. Zu diesen Aufgaben gehört unter anderem das
Anzeigen der Navigationsleiste, und das Ausblenden dieser, wenn eine zusätzliche
Auswahl zu einer Komponente getroffen werden soll. Die Übersichtstabelle und die
Preis-/Gewichtsinformationen werden ebenfalls in der Main.php aufgerufen. Des
Weiteren wird in der Main.php überprüft, ob alle Komponenten ausgewählt wurden
(indem wieder eine Funktion aus der EventHandler Klasse aufgerufen wird)
und erst dann ein Link zum so genannten Showroom angezeigt wird.
5.2.3 Showroom.php
Diese php stellt die schon zusammengestellten Fahrräder dar. Sie kann erst vom
Nutzer aufgerufen werden wenn alle Komponenten ausgewählt wurden. Es werden
drei Tabellen angezeigt, die der Übersichtstabelle auf der Hauptseite gleichen.
Um diese Tabellen mit Daten zu füllen wird ein zweidimensionales Array ausgelesen,
in dem der Unique-Key jedes Rades und jeder ausgewählten Komponente
gespeichert ist. Dieses Array wird in der EventHandler Klasse gefüllt und nach
jeder Auswahl aktualisiert. Ebenso gibt es für den Gesamtpreis und das Gewicht
ein separates zweidimensionales Array in dem diese Daten gespeichert werden.
Das Array wird auch in der Showroom.php ausgelesen und entsprechend auf dem
Bildschirm präsentiert.
Die Daten aus dem Array mit dem Unique-Key der Komponenten werden dann
in der Datei benutzt, um den Namen und Preis aus der Datenbank auszulesen.
Bei Gesamtpreis und -gewicht ist dies nicht notwendig, das es sich hierbei nur um
Session-Variablen handelt.
So lange noch nicht alle drei Renn- oder Triathlonräder konfiguriert sind, wird ein
Link dargestellt, mit dem der Nutzer wieder zurück zur Hauptseite gelangen kann,
um ein weiteres Rad zu konfigurieren. Wurden alle drei Räder zusammengestellt,
wird dieser Link nicht mehr angezeigt, und der Prototyp des Konfigurators endet
hier.
Diplomarbeit 42

KAPITEL 5. DIE PROGAMM-DATEIEN
5.3 XML
5.3.1 XML-Datei
Beim Erstellen der Form der XML-Datei, wie sie im Konfigurator gewünscht ist,
traten mehr Probleme auf, als vorhergesehen war. Zum einen mussten die nötigen
Informationen untergebracht werden, und zum anderen musste die Struktur der
Abhängigkeiten berücksichtigt werden. Ein Beispiel für diese Struktur ist, dass es
einen Zusammenhang von den Komponenten Gabel, Vorbau, Lenker und Aeroaufsatz
gibt. Möchte ein Nutzer, nachdem er diese vier Komponenten ausgewählt hat,
z. B. die Gabel ändern, so muss gleichzeitig die Auswahl der anderen drei Komponenten
rückgängig gemacht werden, da durch eine andere Gabel evtl. der Vorbau
und dadurch evtl. der Lenker usw. nicht mehr zusammenpassen. Diese im Beispiel
genannte Struktur muss in die XML übertragen werden. Allerdings sollte das Auslesen
der Daten nicht zu kompliziert werden. Das heißt, die Ebenen sollten nicht
zu sehr in die Tiefe gehen, da sonst der Code zum Extrahieren zu unübersichtlich
werden würde.
Nach ersten Überlegungen wurde eine XML-Datei erstellt, die zwar genau die
Struktur des Konfigurators wiedergab, aber, wie sich im Nachhinein herausstellte,
dennoch Informationen fehlten. Dieses hier ist ein Codefragment aus dem ersten
Entwurf:
...
ArtNrFork
ArtNrStem
ArtNrBar
ArtNrAero
...
Diplomarbeit 43

KAPITEL 5. DIE PROGAMM-DATEIEN
Also wurden nach dem ersten Entwurf die Daten ergänzt, die wichtig erschienen.
Dies beschränkte sich zunächst darauf, dass zur besseren Extrahierung der Komponenten
und Pfade, die Tags mit einer ID versehen wurden. Danach sah es in der
XML-Datei so aus:
...
ArtNrFork
ArtNrStem
...
Doch nach einigem Arbeiten mit dem Code, das die Daten auslesen sollte, stand
fest, dass es zum einen zu viele Ebenen gab, und somit der Code unübersichtlich
und kompliziert wurde, und zum anderen, dass dort noch weitere Daten eingefügt
werden können und sollen. Der nächste Entwurf hatte also dementsprechend wenige
Ebenen und versuchte auch die geforderte Struktur widerzuspiegeln:
0
ArtNrFame
1
ArtNrHeadset
2
ArtNrFork
2
ArtNrStem
...
Im finalen Entwurf, wurde die XML nicht vereinfacht, aber dennoch so gehalten,
dass die Daten relativ leicht ausgelesen werden konnten. Zusätzlich wurde die
geforderte Struktur noch hervorgehoben und weitere Daten hinzugefügt, die sich
Diplomarbeit 44

KAPITEL 5. DIE PROGAMM-DATEIEN
letztendlich als sehr hilfreich, wenn nicht sogar als unverzichtbar herausgestellt
haben. Ein Teil dieser XML sieht nun so aus:
Rahmen
ArtNrFrame
Steuersatz
ArtNrHeadset
Gabel
ArtNrFork
Vorbau
ArtNrStem
StemLength
...
Aeroaufsatz
ArtNrAero
...
Wie sich erkennen lässt, umfasst der Pfad mit der ID-Nummer 00 alle Baugruppen.
Die anderen Pfade beinhalten lediglich die entsprechende Gruppe von Komponenten,
was - wie schon Eingangs erwähnt - das Entfernen von Komponenten relativ
einfach macht. Die Inhalte der Tags mit dem Namen Unique können natürlich frei
Diplomarbeit 45

KAPITEL 5. DIE PROGAMM-DATEIEN
gewählt werden, sollten aber nicht doppelt vorkommen, da dieser Name in den
php-Skripten als Session-Variable zum speichern des Primary Keys aus der Datenbank
verwendet wird. Der dritte Tag innerhalb eines Component mit dem Namen
Additional ist für zusätzliche Informationen gedacht, die nicht bei jeder Komponente
vorkommen. Im Fall dieses Konfigurators wird nur bei dem Vorbau und bei
dem Kurbelsatz der Additional-Tag gebraucht, um die Vorbau- bzw. Kurbellänge
in Session-Variablen zu speichern.
5.3.2 XML-Handler Klasse
Die Klasse ist nicht nur für das Extrahieren von Daten aus der XML-Datei zuständig,
sie führt auch ein paar Operationen zum Testen durch. Aufgerufen wird die Klasse
mit einem Parameter, der den gewünschten Dateinamen enthält. Im Konstruktor
wird dann mittels der Funktion simple load xml() die XML-Datei als mehrdimensionales
assoziatives Array geladen, und so sind die darin enthaltenen Daten
relativ leicht zu lesen.
Eine der oben angesprochenen Test-Funktionen ist die test set. Sie überprüft
ob alle vorherigen Komponenten in dem Pfad (vgl. Abschnitt 3.1 auf Seite 19)
gesetzt sind, so dass die Komponententabelle mit den kompatiblen Bauteilen angezeigt
werden kann. Dieser Funktion werden zwei Werte übergeben: die Nummer
des Pfades, in der sich die zu testende Komponente befindet und an welcher
Stelle innerhalb des Pfades sie steht. Durch verschiedene foreach-Schleifen und
if-Abfragen wird dann mit dem Programm fortgefahren oder eine entsprechende
Meldung auf dem Bildschirm erscheint, die besagt dass eine andere Komponente
vorher gewählt werden muss.
Die restlichen Methoden sind zum Auslesen der Daten aus der XML-Datei. Es gibt
jeweils Funktionen zum extrahieren des Komponentenamens, der Komponenten-
ID, des Unique-Wertes (also der Artikelnummer) oder der Pfad-ID. Eine dieser
Funktionen ist die get component from xml, die den Komponentennamen aus der
XML liest. Die zu übergebenen Werte sind die Nummer des Bauteils und optional
einen Parameter der angibt in welcher Form dieser Name zurückgegeben werden
soll. Um den gewünschten Namen zu finden wird ebenfalls mit foreach-Schleifen
Diplomarbeit 46

KAPITEL 5. DIE PROGAMM-DATEIEN
und if-Abfragen das Array der eingelesenen XML-Datei durchlaufen. Der optionale
Parameter gibt an, ob der Name mit oder ohne Umlaute zurückgegeben wird.
Zum Beispiel könnte Laufräder oder Laufraeder ausgegeben werden. Dieses zu implementieren
war notwendig, da die MySQL Datenbank keine deutschen Umlaute
in den Table-Namen erlaubt. So werden alle XML-Funktionen, die Table-Namen
verarbeiten, mit diesem optionalen Parameter aufgerufen, um der Namenskonvention
von MySQL gerecht zu werden.
Eine Funktion durchsucht den Pfad (dessen Pfad-ID übergeben werden muss) und
gibt als Array die in diesem Pfad enthaltenen Komponentennummern zurück. Diese
Operation ist notwendig damit bei dem Entfernen einer Komponente auch alle
nachfolgenden Bauteile gelöscht werden. Die weiteren Funktionen sind alle ähnlich
aufgebaut, da die Struktur der XML sich natürlich nicht ändert. Es gibt verschiedene
Funktionen, die die gleichen Daten extrahieren, aber andere Parameter haben.
So lesen die beiden Funktionen get key from xml und get key from name jeweils
den Unique-Key einer Komponente aus, bei der einen wird jedoch die Komponentennummer
übergeben, bei der anderen der Komponentenname (vgl. Abschnitt
6.4.1 auf Seite 70.
Als Beispiel folgt nun der Code einer dieser Funktionen:
public function get_id_from_name ($name) {
foreach ($this->XML->Path as $path)
{
foreach ($path->Component as $component)
{
if ($name == utf8_decode($component->Name))
{
return utf8_decode($component->attributes());
}
}//end-foreach
foreach ($path->Path as $innerpath)
{
foreach ($innerpath->Component as $component)
Diplomarbeit 47

KAPITEL 5. DIE PROGAMM-DATEIEN
{
if ($name == utf8_decode($component->Name))
{
return utf8_decode($component->attributes());
}
}
}//end-foreach
}//end-foreach
}//end-function
Die hier dargestellte Funktion sucht die dazugehörige Nummer des angegebenen
Komponentennamens. In den ersten beiden foreach-Schleifen wird die oberste
Ebene der Pfade durchlaufen. In dem Fall der XML-Datei des Rennrad-Konfigurators
ist es nur die Komponente Rahmen, die in der obersten Ebene zu finden ist (siehe
Seite 44 für den XML-Aufbau). In den nächsten beiden foreach-Schleifen werden
die unteren Ebenen der Pfade durchsucht. Da es in dieser XML nur zwei Ebenen
von Pfaden gibt, ist es meiner Ansicht nach nicht notwendig gewesen, diese rekursiv
zu realisieren. Sollten weitere Pfad-Ebenen erforderlich sein, so wäre es bestimmt
übersichtlicher diese Funktion rekursiv zu programmieren. Wurde der gewünschte
Komponentenname gefunden, so wird die entsprechende Nummer zurückgegeben.
Die Operation utf8 decode wäre hier nicht unbedingt notwendig, aber bei Namen
ist dies unerlässlich, da sonst die Zeichen nicht richtig dargestellt werden.
5.4 Event-Handler Klasse
Die Event-Handler Klasse war ursprünglich nur dazu gedacht die Ereignisse zu verarbeiten.
Mit Ereignissen sind z. B. Klicks auf die Navigationsleiste, den Auswahl-
Button oder die Entfernen-Schaltfläche gemeint. Allerdings sind im Laufe der Entwicklung
mehrere Funktionen hinzugekommen, die auch zur Darstellung auf dem
Bildschirm oder Verarbeitung von Daten dienen.
Diplomarbeit 48

KAPITEL 5. DIE PROGAMM-DATEIEN
5.4.1 Die Ereignisse
Es gibt insgesamt 5 Ereignisse, die auftreten können, und jedes mal einen Klick
auf einen so genannten Submit-Button bedeuten. Diese Events wären ein Klick
auf die Navigationsleiste, auf den Neustart Link und auf den Auswählen- oder
Entfernen Knopf. Bei zwei Komponenten gibt es noch ein Ereignis, bei der eine
zusätzliche Auswahl erscheint. Jedes Event wird in der Main.php registriert und
an die EventHandler Klasse weitergeleitet. Dort wird mittels der get-Funktion
dieses Ereignis an die entsprechende Funktion verteilt und ausgeführt. Als Beispiel
folgt ein Teil des Programmcodes. Zuerst wird ein Event in der Main.php erfasst:
if (isset($_POST[’navigation’]))
$ev->navbar;
Dadurch wird die EventHandler Klasse aufgerufen und somit auch die
Funktion:
get-
public function __get($event)
{
$method = "handle_".$event."_click";
if (is_callable(array($this, $method)))
{
$this->{$method}();
}
}
So werden alle Events zu den entsprechenden Funktionen weitergeleitet. Jedes
dieser Funktionen ist nach dem Muster handle (der Eventname) click benannt. In
diesen Fall wäre es: public function handle navbar click().
Eine Beschreibung wie diese Funktionen im Einzelnen programmiert wurden und
wie sie arbeiten würde den Rahmen dieses Unterpunktes sprengen. Sie werden im
Abschnitt 6.1 näher erklärt.
Diplomarbeit 49

KAPITEL 5. DIE PROGAMM-DATEIEN
5.4.2 Weitere Funktionen
Unter den weiteren Funktionen sind all die zusammengefasst, die sich um Datenauswertung
oder Darstellung auf dem Bildschirm kümmern. Eine sehr wichtige
Funktion ist navibar, die für die Erstellung der Navigationsleiste zuständig ist.
Hier werden zwei Werte übergeben: einmal bei welcher Position die Leiste starten
soll, und einmal die Anzahl nach der die rekursive Funktion abgebrochen werden
soll. Innerhalb der Funktion wird abgefragt, ob es sich um ein Rennrad, oder
um ein Triathlonrad handelt, das konfiguriert werden soll, damit bei Ersterem die
Komponente Aeroaufsatz nicht angezeigt wird. Des Weiteren wird überprüft ob
die entsprechende Komponente schon ausgewählt wurde. Falls dies der Fall ist,
wird das Feld für dieses Bauteil farblich hinterlegt.
Eine Funktion innerhalb der EventHandler Klasse ist für das Darstellen der Übersichtstabelle
zuständig und heißt bezeichnenderweise auch overview table. Sie
wird auch aus der Main.php aufgerufen, und geht alle Komponenten der Reihe
nach durch, um zu überprüfen ob diese ausgewählt wurden. Ist das der Fall, wird
anhand der Artikelnummer, die auch gleichzeitig der Primary Key ist, der Artikelname
und Preis aus der Datenbank gelesen und in der Tabelle angezeigt. Es
sind noch weitere Überprüfungen notwendig, wie etwa der Test ob es sich um ein
Renn- oder Triathonrad handelt und dem entsprechend die Komponente Aeroaufsatz
gehandhabt wird, oder ob eine Komponente durch die Auswahl eines anderen
Bauteils schon vorhanden ist.
overview price ist eine ähnliche Funktion, die allerdings nur für den Gesamtpreis
und -gewicht zuständig ist. Da bei der Speicherung des Sessionwertes keine 0
(Null) übergeben werden kann, muss in dieser Funktion dieses berücksichtigt und
überprüft werden. So wird bei einem nicht gesetzten Sessionwert explizit 0.00e
bzw. 0 g angegeben.
Eine weitere Aufgabe, die die Klasse EventHandler übernimmt, ist nachzuprüfen
ob alle Komponenten ausgewählt wurden, damit ein weiterführender Verweis zu
dem Showroom (vgl. Seite 26 bzw. Seite 42) erscheint. Auch diese Funktion hat
einen entsprechenden Namen, der verdeutlicht wozu sie gebraucht wird: check if all
set(). Hierzu werden alle vorhandenen Komponenten mit dem Befehl $this->
Diplomarbeit 50

KAPITEL 5. DIE PROGAMM-DATEIEN
xml->get ids in path(’00’) in ein Array geladen, um dann alle Elemente mit
einer foreach-Schleife durchzugehen. Sobald eine Komponente nicht gewählt wurde,
wird die Schleife abgebrochen und ein false zurückgegeben. Wenn die Schleife
aber komplett durchlaufen wird, so erscheint auf dem Bildschirm der weiterführende
Link, da ein true zurückgegeben wurde.
Die letzte Funktion, die keine Ereignisse verarbeitet, heißt save item. Es werden
hier die Artikelnummern der ausgewählten Komponenten gespeichert. Da
es möglich ist, bis zu drei Fahrräder zu konfigurieren, und alle später in dem
Showroom dargestellt werden sollen, werden alle Artikelnummern in ein zweidimensionales
Array gespeichert, damit diese Informationen auch später noch
verfügbar sind. Wie dies geschieht soll hier verdeutlicht werden:
public function save_item() {
$num = ($_SESSION[’number’]-1);
$ids = $this->xml->get_ids_in_path(’00’);
foreach ($ids as $single_id)
{
$all[$num][$single_id] =
$_SESSION[$this->xml->get_key_from_xml($single_id)];
}
if ($num > 0)
{
$all = $all + $_SESSION[’all’];
}
$this->session->register_session(all, $all);
...
}
Die Sessionvariable number beinhaltet die Nummer des aktuell konfigurierten Rades.
Da keine 0 (Null) gespeichert werden kann, fängt number bei eins an. Die Variable
$num sollte allerdings wegen dem Array bei 0 (Null) anfangen. In der nächsten
Zeile werden wieder alle vorhanden Komponenten-IDs in ein (ein-dimensionales)
Diplomarbeit 51

KAPITEL 5. DIE PROGAMM-DATEIEN
Array gespeichert. Mit der foreach-Schleife werden nun alle Bauteile nacheinander
durchgegangen und mittels der Komponenten-ID die Artikelnummer aus den
jeweiligen Sessionvariablen im zwei-dimensionalen Array gespeichert. Die nächste
Abfrage ob $num größer Null sei, ist notwendig, da sonst Fehlermeldungen vom
php-Parser auftreten, weil dort zwei Arrays zusammengefügt werden. Schließlich
wird das Array in einer Sessionvariable gespeichert, damit die Informationen erhalten
bleiben.
In der Funktion werden auch Gesamtpreis und Gesamtgewicht in ein separates
zwei-dimensionales Array gespeichert, da auch diese Angaben für alle Fahrräder
im Showroom benötigt werden.
Diplomarbeit 52

Kapitel 6
Das Programm aus Sicht des
Entwicklers
In diesem Kapitel soll näher und detaillierter auf den Programmcode eingegangen
werden. Es werden die Zusammenhänge zwischen den Klassen und einzelnen
Funktionen erläutert, und teilweise wie der Code genau funktioniert.
6.1 Events
In diesem Unterkapitel geht es um die Ereignisse, die bei dem Konfigurator auftreten
können. Insgesamt sind es fünf Events die den gesamten Konfigurator steuern.
Ihre groben Funktionen wurden schon in Abschnitt 5.4.1 angesprochen. Dort wurde
auch gezeigt, wie die Ereignisse in der EventHandler Klasse aufgerufen werden.
Hier soll noch einmal in detaillierter Form darauf eingegangen werden, was genau
in den einzelnen Funktionen passiert, da die Ereignisse ein unverzichtbarer Bestandteil
des Konfigurators sind.
Diplomarbeit 53

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
6.1.1 Navigation
Nachdem der Nutzer auf die Navigationsleiste klickt, wird in der EventHandler
Klasse die handle navbar click-Funktion aufgerufen (vgl. Seite 49). Innerhalb
dieser Funktion wird dann die entsprechende Komponentenklasse aufgerufen. Die
Komponentenklassen wurden in der Main.php mit den Variablen $c01, $c02, . . .
für jede Komponente initialisiert.
function handle_navbar_click()
{
if(empty($_SESSION[’nav’]))
$num = ’01’;
else
$num = $this->xml->get_id_from_name ($_SESSION[’nav’]);
}
eval(’global ${c.$num};’);
${c.$num}->display();
Die erste Abfrage überprüft, ob die Session-Variable, die die aktuelle Komponente
speichert, überhaupt gesetzt ist. Falls es nicht so ist, dann wird die Variable
$num auf 01 gesetzt, damit die Daten für die erste Komponente dargestellt werden
können.
Beinhaltet die Session-Variable nav einen Wert, so wird die zugehörige Komponenten-ID
aus der XML-Datei gelesen. Da der gespeicherte Wert in der Session-
Variable stets mit den Komponentennamen in der XML übereinstimmt, ist dieses
Vorgehen ohne Probleme möglich.
Durch den Befehl eval(’global ${c.$num};’); ist es möglich auf die Methoden
der Komponentenklasse innerhalb der EventHandler Klasse zuzugreifen, da die
Instanz der Komponentenklasse global verfügbar gemacht wird. So ist dann auch
die display()-Funktion problemlos aufrufbar [Tut05].
Das ${c.$num} ist eine so genannte variable Variable“. Je nach der aus der XML
”
ausgelesenen Komponenten-ID, wird eine andere Komponentenklasse aufgerufen.
Diplomarbeit 54

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
6.1.2 Entfernen
Zuerst wird die handle remove click-Funktion aufgerufen, und danach die entsprechende
Komponentenklasse. Dies geschieht nach dem gleichen Mechanismus,
wie bei der handle navbar click-Funktion. Mit dem Befehl ${c.$num}->
remove(); wird die entsprechende Funktion in der Komponentenklasse aufgerufen,
die je nach Komponente sofort in der Elternklasse die Remove-Routine aufruft,
oder vorher noch bestimmte Session-Variablen entfernt, wie z. B. die Schaltgruppen-
Marke. Durch ${c.$num}->display(); werden dann sofort die kompatiblen Komponenten
wieder angezeigt. Mit dem anschließenden Befehl $this->save item();
werden die aktuellen Daten in ein zwei-dimensionales Array gespeichert (siehe Seite
51).
6.1.3 Auswahl
Auch die handle choice click-Funktion ist ähnlich aufgebaut und wird genau
so wie die anderen Methoden aufgerufen. Es wird erst die entsprechende Komponentenklasse
aus der Navigations-Session-Variable ermittelt und global verfügbar
gemacht. Danach wird die Funktion ${c.$num}->set session() aufgerufen, die
innerhalb der Komponentenklasse die Session-Variable für die Komponente und
andere Variablen setzt. Um zu verhindern, dass ein mehrmaliges Klicken auf den
Auswahl-Button einen Effekt hat, muss eine if-Abfrage dieses testen. Außerdem
darf es nicht passieren, dass ein anderer Artikel gewählt werden kann, ohne dass
vorher der Entfernen-Button angeklickt wurde. Durch diese Abfrage wird das realisiert:
if (empty($_SESSION[$this->xml->get_key_from_xml($num)]) or
$_POST[$this->xml->get_key_from_xml($num)] !=
$_SESSION[$this->xml->get_component_from_xml($num)])
{
${c.$num}->set_session();
}
Diplomarbeit 55

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Es werden hier zwei Dinge überprüft. Zum einen ob die Session-Variable überhaupt
gesetzt ist, denn ist das nicht der Fall, so wurde diese Komponente vorher noch
nicht ausgewählt und es ist somit zulässig die entsprechenden Variablen zu setzen.
Die zweite Überprüfung nach dem or testet, ob der gerade ausgewählte Artikel
nicht identisch mit der schon gespeicherten Komponente ist. Dadurch wird
gewährleistet, dass alle Klicks auf den Auswahl-Button dieser Komponente ignoriert
werden, solange nicht vorher dieses Bauteil wieder entfernt wird.
6.1.4 Zusätzliche Auswahl
Damit die Komponententabelle nicht zu lang und unübersichtlich wird, war es
notwendig eine zusätzliche Auswahl für die Längen bestimmter Komponenten zu
implementieren (vgl. Abschnitt 3.2.2 auf Seite 23).
Grundsätzlich unterscheidet sich die handle additional click nicht von der
handle choice click-Funktion. Es wird ebenfalls die gleiche if-Abfrage benutzt
um mehrmaliges Anklicken des Auswahl-Buttons zu verhindern. Der einzige Unterschied
besteht darin, dass nach dem Befehl ${c.$num}->set session() noch
ein ${c.$num}->additional() folgt, in dessen Funktion dann die zusätzliche Auswahl
in der dazugehörigen Komponentenklasse abgehandelt wird.
6.1.5 Reset
Diese Funktion ist dafür zuständig, dass nach dem Klicken des Neustart-Buttons
alle relevanten Session-Variablen gelöscht werden. Auch hier läuft der Aufruf der
Methode nach diesem Event nach dem gleichen Muster ab, wie bei den Anderen.
Im Grunde ist der Vorgang des Neustarts ähnlich dem des Löschens des Rahmens:
Alle Komponenten-Session-Variablen werden gelöscht. Dennoch werden hier noch
zusätzliche Variablen, wie Gesamtpreis und -gewicht gelöscht, während diese Daten
beim Entfernen des Rahmens nur neu berechnet werden.
Der Aufruf aus der Main.php lautet hier im Übrigen $ev->reset und somit die
Funktion in der EventHandler Klasse handle reset click(), da das Wort reset
schon für eine andere Funktion reserviert ist.
Diplomarbeit 56

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
public function handle_reset__click()
{
eval(’global $c01;’);
$ids = $this->xml->get_ids_in_path(’00’);
foreach ($ids as $single_id)
{
if (1 session->unregister_session(
$this->xml->get_key_from_xml($single_id));
}
}
$this->session->unregister_session(brand);
$this->session->reset_sessionvalue(weight);
$this->session->reset_sessionvalue(price);
$this->session->unregister_session(nav);
$navigation = $this->xml->get_component_from_xml(1);
$this->session->register_session(nav, $navigation);
$c01->display();
}
$this->save_item();
Zuerst wird die Instanz der Komponentenklasse global verfügbar gemacht, so dass
auf die Funktionen dieser Klasse innerhalb der EventHandler Klasse darauf zugegriffen
werden kann. Hier wird nur die Komponentenklasse des Rahmens aufgerufen,
da nach einem Neustart in jedem Fall der Rahmen als erstes benötigt
wird. Dann werden alle vorhandenen Komponenten-IDs in ein Array geladen, damit
sie mit einer foreach-Schleife bequem abgearbeitet werden können. In der
darauf folgenden Schleife werden die gesamten Komponenten-Session-Variablen
Diplomarbeit 57

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
gelöscht, und in den nächsten vier Zeilen die anderen relevanten Variablen, wie
Preis, Gewicht oder Navigation. Danach wird in den beiden folgenden Zeilen die
Navigation auf dem Rahmen gesetzt und mit dem Befehl $c01->display() wird
die Komponententabelle dargestellt. Anschließend wird noch das Ganze im zweidimensionalen
Array aktualisiert durch die $this->save item()-Instruktion.
6.2 Komponentenklassen
Jede Komponente hat ihre eigene Klasse, da jedes Bauteil verschiedene Anforderungen
mit sich bringt, bzw. verschiedenste Abhängigkeiten haben. Dies konnte am
besten und am übersichtlichsten gestaltet werden, indem jede Komponente ihre eigene
Klasse bekam, in der die Bauteilspezifischen Eigenheiten bearbeitet werden
können. Wie schon in Abschnitt 6.1.1 beschrieben, haben die Klassen, wegen der
einfacheren Bearbeitung, eine bestimmte Objektvariable. Die Erzeugung der vierzehn
Komponenten-Objekte geschieht in der Main.php und sieht folgendermaßen
aus:
for ($i = 1; $i < 15; $i++)
{
$num = sprintf("%02d", $i);
$com_function = "Component".$num;
}
${c.$num} = new $com_function($db,$sh,$xm);
Hier wird eine Schleife durchlaufen, in der z. B. bei der Erzeugung des Objekts für
Component01 die Variable $c01 zugewiesen wird. Das geschieht bei allen vierzehn
Komponenten. An den Constructor (in der Elternklasse) werden die Referenzen
zu den Objekten des DBHandlers, des SessionHandlers und des XMLHandlers
übergeben, damit die Funktionen dieser Klasse auch innerhalb der Komponentenklassen
verfügbar sind.
Diplomarbeit 58

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Aufgrund der vielen verschiedenen Anforderungen jeder Komponente, beinhaltet
jede Klasse zwar Funktionen, die bei jedem Bauteil gleich sind, aber andere Fahrradelemente
haben zusätzliche Funktion, die für besondere Aufgaben benötigt werden.
Als Beispiel sei die additional info-Funktion genannt, die nur bei ein paar
Komponenten gebraucht wird, und einen kleinen Infotext auf dem Bildschirm anzeigt.
Natürlich ist der Inhalt der gemeinsamen Funktion je nach Anforderung der Komponente
verschieden. Da es den Umfang einer Diplomarbeit übersteigen würde,
wird aber darauf verzichtet den Code jeder einzelnen Funktion jeder Komponentenklasse
eingehend zu beschreiben. Nur auf die generellen Aufgaben mit kleinen
Code-Beispielen so hier eingegangen werden.
6.2.1 Funktion set session
Innerhalb dieser Funktion wird dafür gesorgt, dass die eindeutige Artikelnummer
in den entsprechenden Session-Variablen gespeichert wird. Des Weiteren werden
bei Bedarf weitere Session-Variablen gesetzt, so z. B. wenn der Rahmen schon
mit einer Gabel geliefert wird. Bei jedem Klick auf den Auswahl-Button wird die
eindeutige Artikelnummer als POST-Variable übergeben. Durch diese Befehlsfolge
wird zuerst abgefragt ob die POST-Variable überhaupt gesetzt ist, um dann in der
Session-Variable gespeichert zu werden. In diesem Beispiel wird die Artikelnummer
der ersten Komponente, also des Rahmens, gespeichert.
$component01 = isset($_POST[$this->xml->get_component_from_xml(1)])
? $_POST[$this->xml->get_component_from_xml(1)]
: ’’;
$this->session->register_session($this->xml->get_key_from_xml(1),
$component01);
Dieser Teil wird in jeder Komponentenklasse ausgeführt. Das Folgende wird nur
angewendet, wenn eine Komponente Auswirkungen auf andere Bauteile hat.
Diplomarbeit 59

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Die nächste Instruktion dient dazu anhand der Artikelnummer den gesamten Datensatz
aus der Datenbank zu lesen und lautet $choice = $this->db->
GetComponentArray($ SESSION[$this->xml->get key from xml(1)],
$this->xml->get component from xml(1)). Der Befehl GetComponentArray hat
zwei Argumente. Das Erste ist der Name, den die Session-Variable erhält, also die
eindeutige Artikelnummer. Das zweite Argument ist der Name der Table, in dem
der Artikel gespeichert ist. Das zurückgegebene Ergebnis ist ein Array, in dem die
Werte aus der Datenbank nacheinander abgelegt sind.
Danach werden, je nach Komponente und Artikel, die anderen Session-Variablen
gesetzt. Um bei dem Beispiel des Rahmens zu bleiben, wird dann abgefragt ob
andere Komponenten bei diesem Rahmen schon vorhanden sind. Dafür werden die
aus der Datenbank ausgelesenen Informationen verwertet.
if ($choice[8] == 1)
{
$this->session->register_session(
$this->xml->get_key_from_xml(3), ’Vorhanden’);
}
else if ($choice[8] == 0 and
$_SESSION[$this->xml->get_key_from_xml(3)] === ’Vorhanden’)
{
$this->session->reset_sessionvalue(
$this->xml->get_key_from_xml(3));
}
Hier wird in der if-Abfrage überprüft ob der ausgewählte Rahmen schon eine Gabel
besitzt. Falls das so ist, wird die Session-Variable für die Gabel mit dem Wert
Vorhanden“ besetzt.
”
Die nächste Abfrage gilt dafür wenn ein Rahmen, der eine Gabel besitzt, ausgewählt,
dann aber gelöscht wird, und danach ein Rahmen ohne Gabel gewählt
wird. Das ”
Vorhanden“ wird aus der Session-Variable gelöscht wenn der gewählte
Rahmen keine Gabel besitzt und wenn diese Variable mit ”
Vorhanden“ belegt ist.
So ähnlich funktioniert es bei jeder Komponente, die Auswirkungen auf andere
Diplomarbeit 60

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Bauteile hat. Dabei muss es nicht nur darum gehen, ob eine andere Komponente
vorhanden ist oder nicht, sondern auch welche Schaltgruppenmarke verwendet
wird.
Der nächste Befehl parent::update it($this->xml->get id from name
($ SESSION[’nav’]), 1) wird auch in jeder Komponentenklasse verwendet, denn
er aktualisiert den Gesamtpreis bzw. -gewicht. Die Ausführung wird durch die Elternklasse
erledigt. Die beiden Argumente, die übergeben werden, sind zum einen
die Komponenten-ID, und zum anderen das Vorzeichen. D.h. das Vorzeichen bestimmt
ob der Betrag zum Gesamtergebnis addiert oder davon subtrahiert wird.
6.2.2 Funktion display
Dieses ist wohl die wichtigste Funktion im Programm des Konfigurators. Nicht
nur, weil hier die Komponententabelle mit den Auswahl- und Entfernen-Buttons
erzeugt wird, sondern auch weil in dieser Funktion die nicht kompatiblen Bauteile
ausgefiltert werden. Deshalb mag der Funktionsname etwas in die Irre führen, da
hier mehr geleistet wird als nur das Darstellen. Als Beispiel, an dem die Funktionen
erklärt werden sollen, sei hier die Komponente 13 (die Sattelstütze) aufgeführt, da
dort zwar alle wichtigen Aufgaben vorkommen, aber dennoch diese Funktion nicht
zu kompliziert ist, und zu viel Code enthält.
Bei jedem Klick auf die Navigationsleiste wird, bevor die Komponententabelle
dargestellt wird, eine Überprüfung gestartet, ob die vorangegangenen Komponenten
dieses Pfades schon ausgewählt wurden. Dieses geschieht durch eine einfache
if-Abfrage und lautet in diesem Beispiel if ($this->xml->test set(4,1)). Die
beiden Argumente in der Funktion zeigen an, dass dies der vierte Pfad, und die Sattelstütze
darin die erste Komponente ist. Also muss hier nur der Rahmen gewählt
sein, damit die Komponententabelle für dieses Bauteil angezeigt wird.
Als nächstes werden die Daten des ausgewählten Rahmens mittels der schon bekannten
Funktion GetComponentArray in ein Array geladen. Die Sattelstütze ist
von den Vorgaben des Rahmens abhängig (vgl. Abschnitt 2.2) und deshalb ist es
notwendig diese Daten zu ermitteln. Der Rest der display-Funktion besteht aus
Diplomarbeit 61

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
einer if-else-Abfrage, in der geprüft wird, ob der vorher ausgewählte Rahmen
nicht schon eine Sattelstütze besitzt, in dem der Ausdruck if ($FrameRow[10] >
90) verwendet wird. In der Datenbank ist an dieser Stelle normalerweise der Durchmesser
vermerkt. Ist dieser Wert aber über 90, so interpretiert das Programm es
aber als eine schon vorhandene Sattelstütze. Ähnliche Abfragen gibt es auch für
den Aeroaufsatz, die Gabel oder den Steuersatz. Ist diese if-Abfrage wahr, so wird
der Text Sattelstütze schon vorhanden“ ausgegeben.
”
Der restliche Code befindet sich im else-Teil der Abfrage. Der einfacheren Beschreibung
halber ist er hier abgebildet:
$dbquery = "SELECT * FROM ".$this->xml->get_component_from_xml(13,1)
. "WHERE durchmesser between ".($FrameRow[10]-0.01)
. " and " . ($FrameRow[10] + 0.01);
$SeatpostResultSet = $this->db->query_db($dbquery);
echo "";
while ($SeatpostRow = mysql_fetch_row($SeatpostResultSet))
{
$artnr = $_SESSION[$key13];
parent::display_head($SeatpostRow);
echo "
Durchmesser: ".$SeatpostRow[7]."mm
Länge: ".$SeatpostRow[6]."mm
";
parent::display_footer($SeatpostRow, $artnr);
}
echo "";
Der $dbquery-String ist die Anfrage an die Datenbank, nur diejenigen Datensätze
herauszusuchen, die gleich dem Durchmesser der Sattelstütze des Rahmens ist.
Der Ausdruck between ".($FrameRow[10]-0.01). " and ".($FrameRow[10] +
Diplomarbeit 62

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
0.01)" ist notwendig, da MySQL Probleme mit der Genauigkeit von Nachkommastellen
hat. In der nächsten Zeile wird diese Anfrage abgeschickt, und das Ergebnis
wird in $SeatpostResultSet gespeichert.
Nun beginnt die eigentliche Erstellung der Komponententabelle. Solange noch Datensätze
vorhanden sind, wird die while-Schleife ausgeführt. Der obere Teil der
Tabelle eines Artikels wird in der Elternklasse durchgeführt, da immer Preis, Name,
Artikelnummer usw. dort dargestellt werden. In der Funktion display footer
wird der untere Teil der Tabelle angezeigt, der das Gewicht, den Auswahl-Button
und ggf. den Entfernen-Button beinhaltet.
Dazwischen können weitere, komponentenspezifische Informationen, eingefügt werden,
so wie es in dem Beispiel zu sehen ist.
6.2.3 Weitere Funktionen
Bei den weiteren Funktionen handelt es sich, bis auf remove, um Funktionen
die nicht in jeder Komponentenklasse vorkommen. Da wäre additional und die
additional info-Funktion, die eine Informationsbox darstellt.
Bei remove handelt es sich, wie der Name vermuten lässt, um eine Funktion,
die die Aufgabe des Entfernens von Komponenten hat. Bei vielen Komponentenklassen
wird einfach der Befehl parent::remove components($this->xml->
get path id from name($ SESSION[’nav’]), $this->xml->get id from name
($ SESSION[’nav’])) ausgeführt. Doch bei Bauteilen, die mit der Schaltgruppenmarke
zusammenhängen, müssen in dieser Funktion noch zusätzlich einige Abfragen
vorhanden sein, bei denen getestet wird, ob die Session-Variable der Marke
gelöscht werden kann. Das sieht dann, wie z. B. bei den Laufrädern, so aus:
$var = $this->db->GetComponentArray(
$_SESSION[$this->xml->get_key_from_xml(9)],
$this->xml->get_component_from_xml(9,1));
if ( (empty($_SESSION[$this->xml->get_key_from_xml(9)]) or
$var[17] == 2) and
Diplomarbeit 63

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
{
}
empty($_SESSION[$this->xml->get_key_from_xml(10)]))
$this->session->reset_sessionvalue(brand);
Die Funktion additional ist ähnlich der display. Nur werden hier nicht vorher
die nicht kompatiblen Artikel herausgefiltert und dann angezeigt, sondern die verschiedenen
Längen der ausgewählten Komponente aus der Datenbank ausgelesen
und dann als eigene Komponententabelle dargestellt. Diese Funktion wird aber
nur bei dem Vorbau und bei den Kurbelsätzen gebraucht.
Zum Darstellen wird einfach der Datensatz des ausgewählten Artikels aus der Datenbank
extrahiert und die verschiedenen Längen nacheinander mittels einer for-
Schleife angezeigt. Die Funktionen der Elternklasse display head und display
footer kommen auch zum Einsatz, damit erstens diese zusätzliche Tabelle sich
nicht vom Aussehen her viel von der Komponententabelle unterscheidet, und zweitens
wird der Code wieder verwendet.
Abschließend ist in diesem Abschnitt noch die Funktion additional info zu nennen,
die gegebenenfalls aus der display aufgerufen wird, denn nicht jede Komponente
bedarf einer zusätzlichen Information oder Erklärung. Das Ganze ist auch
dynamisch gestaltet, so dass machen Information nicht mehr erscheinen wenn z. B.
die Schaltgruppenmarke schon gewählt wurde.
6.3 Elternklasse
Alle verwendeten Komponentenklassen sind von der Elternklasse abgleitet. Der
Name der php ist bezeichnenderweise ComponentParent. Hier sind alle Methoden
zusammengefasst, die von allen Komponenten benutzt werden. Hier werden
auch über den Konstruktor die Funktionen der Klassen, die XML-, Datenbankoder
Sessionangelegenheiten erledigen, verfügbar gemacht. Die Elternklasse hat
drei Aufgaben: Das Entfernen von Komponenten, das Darstellen der Komponententabelle
und die Berechnung von Gesamtpreis und -gewicht.
Diplomarbeit 64

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Im Folgenden wird auf die Methoden detailliert eingegangen und erklärt wie sie
aufgebaut sind und funktionieren.
6.3.1 Komponentendarstellung
Dieser Teil des Programms ist sehr wichtig und auch etwas kompliziert, da hier
nicht nur die Komponententabelle erstellt wird, sondern auch noch die Klicks auf
den Auswahl- bzw. gegebenenfalls auch den Entfernen-Button gehandhabt werden
müssen.
Die Darstellung ist in zwei Teile gegliedert. Dies wurde so realisiert damit noch
komponentenspezifische Informationen in der Tabelle aufgenommen werden können,
wie z. B. die Breite bei den Reifen. Der obere Teil enthält immer die gleichen Daten,
wie Preis oder Artikelname. Der unter Abschnitt beinhaltet nur die Information
über das Gewicht und die beiden wichtigen Schaltflächen.
display head
Hier wird, wie der Name schon aussagt, der obere Teil der Komponententabelle
erzeugt. Der Methode wird nur ein Parameter übergeben, das hier $field genannt
ist. $field ist ein Array, das die aus der Datenbank ausgelesenen Daten für den
gerade darzustellenden Artikel enthält. Da die Informationen hier angezeigt werden
sollen, die in der Datenbank für jede Komponente an der gleichen Stelle gespeichert
sind, stehen diese Daten auch im übergebenen Array immer am selben Ort. Daher
beinhaltet z. B. $field[0] immer die Artikelnummer, oder $field[4] immer den
Preis usw. (vgl. Abschnitt 4.1.1). Somit ist es sehr leicht die obere Sektion der
Tabelle zu erzeugen, da hier hauptsächlich nur HTML-Code gebraucht wird, in
dem die einzelnen Elemente des Array eingebettet werden.
display footer
In dieser Methode werden, neben dem Gewicht, die unverzichtbaren Schaltflächen
für die Auswahl bzw. das Entfernen einer Komponente angezeigt, und so erstellt,
Diplomarbeit 65

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Abbildung 6.1: Aufteilung zwischen Footer und Head
dass der Event des Anklickens registriert werden kann. Dieser Funktion können drei
Parameter übergeben werden, wobei zwei davon optional sind. Das oben schon beschriebene
Array $field muss jedes Mal übergeben werden. Optional sind die Informationen
über die Artikelnummer eines eventuell schon ausgewählten Bauteils,
und der Parameter, der aussagt, ob es sich nun um eine normale Komponententabelle,
oder um eine zusätzliche Auswahl handeln soll. Wird Letzteres weggelassen,
so wird automatisch eine normale Komponententabelle erstellt, da dies der vorgegebene
Wert ist.
Der normale Ablauf, ohne eine nachträgliche zusätzliche Auswahl, wird folgendermaßen
durchgeführt: In der jeweilige Komponentenklasse wird diese Funktion
in der Elternklasse aufgerufen. Das aus der Datenbank gelesene Array und die
Artikelnummer eines evtl. schon ausgewählten Bauteils werden übergeben und
dann der untere Teil der Tabelle dargestellt. Dieser Teil beginnt mit dem Gewicht.
Danach wird eine Abfrage ausgeführt, die testen soll, ob die Artikelnummer des
gerade darzustellenden Artikels, mit der gepeicherten Nummer in der entsprechenden
Session-Variablen übereinstimmt. Ist das der Fall, so wird die Schaltfläche zum
Entfernen bei diesem Bauteil angezeigt. Dann wird der Auswahl-Button angezeigt,
Diplomarbeit 66

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
der natürlich wieder bei jedem Artikel dargestellt wird.
Die beiden Schaltflächen zum Auswählen oder Entfernen sind HTML-Formulare,
und haben jeweils versteckte Felder, damit z. B. der eingetretene Event in der
Main.php registriert werden kann.
echo "";
echo "";
echo "";
echo "";
Dies hier ist das Formular für das Entfernen, was nur bei dem Bauteil erscheint,
das vorher ausgewählt wurde. Der Name lautet remove, so dass das Ereignis in
der Main.php als remove“ erkannt wird. Der Wert der Artikelnummer, die in
”
$field[0] gespeichert ist, wird bei der jetzigen Version des Prototypen nicht
mehr verwendet, und wurde während der Entwicklungszeit zu Überprüfungszwecken
gebraucht.
echo "";
echo "";
echo "";
echo "";
echo "";
Diplomarbeit 67

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Das Formular für den Auswahl-Button hat zwei versteckte Felder. Außerdem ist
der Name des sichtbaren und eines versteckten Feldes variabel. Der Grund dafür
ist, dass unterscheiden werden muss, ob es nun die Auswahl-Schaltfläche bei einer
normalen Komponententabelle, oder ein Button bei einer zusätzlichen Auswahl
handelt. Das zweite versteckte Feld ist notwendig, damit später auch der ausgewählte
Artikel in der Session-Variable abgespeichert werden kann.
Die Variable $name kann die Werte additional oder auswahl annehmen. Also
kann je nach Namen eine andere POST-Variable abgefragt, und somit ein anderes
Ereignis registriert werden. Dazu muss in der Komponentenklassenmethode
display der dritte Parameter explizit übergeben werden, so dass, nachdem der
Artikel ausgewählt wurde, die Funktion zur Darstellung der zusätzlichen Auswahl
aufgerufen werden kann.
6.3.2 Komponenten entfernen
In dieser Funktion der Elternklasse wird das Entfernen der Komponenten in einem
Pfad gehandhabt. Die Methode ist in dieser Klasse, da das Löschen bei jedem
Bauteil der gleiche Vorgang ist.
Hier werden zwei Parameter beim Aufruf übergeben. Zum einen die ID des Pfades,
die $comp id genannt wird, und zum anderen $path id, die Position an der sich
die zu löschende Komponente innerhalb des Pfades befindet. Dies ist notwendig,
damit die nachfolgenden Bauteile auch gelöscht werden um Inkompatibilitäten der
Elemente zu vermeiden.
Zunächst wird der Befehl $ids = $this->xml->get ids in path($path id) ausgeführt,
damit aus der XML alle Komponenten eines Pfades in ein Array gespeichert
werden. Der eigentliche Löschvorgang ist eine einfache foreach-Schleife.
foreach ($ids as $single_id)
{
if ($comp_id update_it($single_id, -1);
Diplomarbeit 68

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
}
}
$this->session->unregister_session
($this->xml->get_key_from_xml($single_id));
In der Schleife werden erst einmal alle in dem Array befindlichen Komponenten
durchgegangen. Falls nun die Nummer des Indexes (also $single id höher oder
gleich der angegebenen Position innerhalb des Arrays ist, so werden die Komponenten
entfernt. Das bedeutet, dass alle nachfolgenden Bauteile innerhalb des
Pfades ebenfalls gelöscht werden. Das eigentliche Entfernen geschieht durch die Anweisung
$this->session->unregister session, in dem als Argument der Name
der Session-Variable steht. Dieser wird ebenfalls mittels der $single id) aus der
XML gelesen.
Die Session-Variable mit dem Namen brand, die keine Komponente ist, muss unter
bestimmten Umständen ebenfalls gelöscht werden. Das geschieht wenn keine der
Bauteile Laufräder, Kurbelsatz oder Schaltgruppe ausgewählt sind bzw. wenn eine
gelöscht, und keine der anderen Komponenten gewählt wurde. Das Ganze wird
durch eine einfache if-Abfrage realisiert, in der das Vorhandensein der Bauteile
geprüft und mittels UND verknüpft werden.
6.3.3 Preis- und Gewichtsaktualisierung
Der Zweck dieser Methode ist es, den angezeigten Gesamtpreis und das Gesamtgewicht
aktuell zu halten. Dazu wird beim Aufrufen der Funktion als Parameter die
ID der Komponente, dessen Gewicht und Preis addiert bzw. subtrahiert werden
soll, übergeben. Als zweiter Wert wird das Vorzeichen (also eine 1 oder eine -1)
angegeben.
Es wird als erstes innerhalb der Funktion die Daten der Komponente aus der
Datenbank gelesen und in ein Array gespeichert. Dies geschieht wieder mit der
Methode GetComponentArray. An Position 1 im Array befindet sich immer der
Wert des Gewichts und an Position 4 immer der Preis. Diese Werte werden dann
zu der entsprechenden Session-Variable hinzuaddiert bzw. abgezogen.
Diplomarbeit 69

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
$weight = $_SESSION[’weight’] + ($info[1] * $sign);
$price = $_SESSION[’price’] + ($info[4] * $sign);
Falls Gewicht oder Preis gleich 0 (null) ist, wird die Session-Variable zurückgesetzt,
da bei einer Speicherung der Wert 0 (null) nicht zulässig ist, und ignoriert wird.
Das wird durch eine if-Abfrage für die jeweiligen Variablen realisiert. Zu letzt
werden dann $price und $weight in den Session-Variablen gespeichert, wobei
$price vorher auf zwei Nachkommastellen gerundet wird.
6.4 Weitere Klassen
In diesem Abschnitt soll es um die Beschreibung der restlichen Klassen gehen.
Zum Teil, weil sie schon recht ausführlich behandelt wurden (wie die XML Handler
Klasse), oder aus dem Grund, weil die Funktionen nicht so umfangreich sind, dass
ein ganzer Abschnitt dafür gerechtfertigt wäre.
6.4.1 XML Handler Klasse
Diese Klasse wurde in Abschnitt 5.3.2 schon recht ausführlich beschrieben. Auch
der Aufbau wurde in der Sektion 5.3.1 schon behandelt. Hier sollen einmal alle
Methoden der Klasse aufgeführt werden, damit ein Überblick geschaffen wird, was
diese Klasse alles auslesen und bearbeiten kann.
construct Der Konstruktor hat einen String als Parameter, der den Dateinamen
angibt. So kann beim instanzieren schon die Datei geladen werden, ohne noch
einen zusätzlichen Befehl auszuführen.
test set Diese Methode wurde schon in Abschnitt 5.3.2 ausführlich erklärt. Sie
dient zum Testen, ob eine an der Navigationsleiste angeklickte Komponente
schon an der Reihe ist.
get component from xml Hier werden zwei Parameter übergeben: Der Name der
Komponente (üblicherweise in der Session-Variable nav enthalten) und ein
Diplomarbeit 70

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Operator, der bestimmt, ob Umlaute normal oder MySQL-konform zurückgegeben
werden.
umlaute In dieser Funktion werden die Umlaute ersetzt, so dass beispielsweise aus
einem ä ein ae wird.
get key from xml Der Name, den eine Session-Variable für eine bestimmte Komponente
haben soll, wird durch diese Methode ausgelesen. Der Übergabeparameter
ist die Nummer der Komponente.
get key from name Hier wird ebenfalls der Name der Session-Variable für eine
Komponente extrahiert. Allerdings ist der Parameter der Komponentenname.
get id from name Die Id-Nummer einer Komponente wird hier ausgelesen, und
es wird der Name der Komponente übergeben.
get path id from name Eine ähnliche Funktion wie get id from name, nur dass
hier die ID-Nummer des Pfades zurückgegeben wird.
get additional from xml Hier wird der Name der Session-Variable ausgelesen,
die zusätzliche Attribute speichert. Im Fall des Konfigurators sind das die
Länge vom Vorbau bzw. die Länge der Kurbel am Kurbelsatz. Hier muss als
Parameter die Komponenten ID angegeben werden. . .
get additional from name . . . während hier der Name der Komponente übergeben
werden sollte. Ansonsten sind die Funktionen ähnlich.
get ids in path In dieser Methode werden alle Komponenten-IDs in einem Array
zurückgegeben, die in einem bestimmten Pfad sind. Hierzu muss als Übergabewert
natürlich die Pfad-ID angegeben werden.
Diese Methoden extrahieren also alle benötigten Daten aus der XML-Datei, die
zur Funktion des Konfigurators verwendet werden. Es gibt noch weitere Kombinationen
um Daten aus der XML auszulesen, wie beispielsweise anhand des Session-
Variablen-Namens die Komponenten-ID zu erfassen. Allerdings macht das nicht
viel Sinn, und findet auch keine Verwendung im Konfigurator.
Diplomarbeit 71

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
6.4.2 Session Handler Klasse
In dieser Klasse werden alle Funktionen, die die Session-Variablen und dessen
Inhalte manipulieren, zusammengefasst. Die wichtigsten und am häufigsten gebrauchten
Methoden sind register session, unregister session und reset
sessionvalue.
Bei register session wird, wie der Name schon vermuten lässt, eine Session-
Variable registriert. Zwei Parameter werden übergeben. Einmal der Name, den
diese Variable bekommen soll, und einmal der Wert dieser Variable. Es wird aber
noch überprüft, ob der Wert eine 0 (null) oder ob der false ist. Falls dem nicht so
ist, wird die Variable registriert. Daher muss bei Werten, die eine 0 (null) besitzen
dürfen, wie z. B. der Gesamtpreis, eine andere Lösung gefunden werden.
Die Methode unregister session bewirkt das Gegenteil. Hier muss allerdings
nur der Name der Session-Variablen beim Aufruf angegeben werden. Es wird noch
getestet, ob die angegebene Variable überhaupt einen Wert besitzt.
Der Unterschied zu unregister session liegt bei reset sessionvalue darin,
dass die Variable selbst nicht gelöscht wird, sondern nur der Inhalt auf NULL. Die
ist manchmal hilfreich, wenn z. B. nach einem Neustart ein paar Session-Variablen
sofort abgefragt werden, wie es bei Gesamtpreis und -gewicht der Fall ist.
In der Klasse befinden sich noch andere Funktionen wie get session id oder
is registered, die nur während der Entwicklungszeit benutzt wurden, um die
Funktionalität zu testen oder um Fehler zu finden.
6.4.3 Datenbank Handler Klasse
Alles was, sich um die Benutzung der Datenbank und dessen Funktionen dreht,
befindet sich in dieser Klasse. Auch hier gibt es Methoden, die ständig benutzt
werden, und es gibt Methoden, die nur während der Entwicklung des Konfigurators
gebraucht wurden.
Eine der häufig verwendeten Funktionen ist query db. Es gibt natürlich die vorgefertigte
Funktion mysql query, doch bei der Benutzung von query db wird im
Fehlerfall der Errorcode und der Fehler ausgegeben.
Die Methode GetComponentArray ist ebenfalls eine sehr oft benutzte Funktion.
Diplomarbeit 72

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Mit ihr ist es möglich den kompletten Datensatz eines Artikels auszulesen. Dazu
müssen zwei Parameter übergeben werden. Der Eine ist der Name des Tables,
und der Andere ist die Artikelnummer, was auch gleichzeitig den Primary Key
darstellt. Zurückgegeben wird ein Array, das alle in der Datenbank gespeicherten
Informationen über diesen Artikel enthält.
Erwähnenswert ist noch der Konstruktor. Ihm wir bei der Instanzierung ein String
übergeben, der dann bestimmt, ob eine Verbindung zum Server der lokalen Entwicklungsumgebung,
oder zum Webserver hergestellt werden soll. So muss, wenn
der Konfigurator auf den Webserver hochgeladen wird, nur der String geändert
werden. Eine relativ komfortable Lösung, wenn man in Betracht zieht, dass die
MySQL und PHP Versionen von den beiden Umgebungen nicht hundertprozentig
kompatibel sind.
Die restlichen Methoden wie create db, select db, delete db, oder auch
select table, finden nur Verwendung im recht rudimentären Backend, das sich
darauf beschränkt, dass man die gesamte Datenbank löschen, dessen Inhalt anschauen,
oder mit den Testdaten befüllen kann.
6.5 Interaktionen
Nachdem nun die gesamten Klassen detailliert durchgesprochen und erklärt wurden,
sind nun die Interaktionen zwischen den Klassen das Thema dieses Abschnitts.
Es werden nicht alle möglichen Zusammenspiele angesprochen, da das den Rahmen
sprengen würde.
Der Konfigurator wird, wie schon mehrmals erwähnt, durch Ereignisse gesteuert,
und in Gang gesetzt. Es werden hier exemplarisch drei Events besprochen und
erklärt. Das geschieht jeweils anhand eines Diagramms, dem ein paar erklärende
Sätze folgen, zu Stellen, an denen die Darstellung nicht ganz klar sein könnte.
6.5.1 Event: Navigation
Nach dem Klick auf die Navigationsleiste wird die Main.php erneut aufgerufen,
und die POST-Variable navigation wird gesetzt. Das wird dann registriert und
Diplomarbeit 73

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
die Funktion handle navbar click in der EventHandler-Klasse aufgerufen. Der
Inhalt der POST-Variable navigation wird in der Session-Variablen nav gespeichert,
und mit dessen Hilfe und der XML-Funktion get id from name die Methode
display der entsprechenden Komponentenklasse aufgerufen. In dieser Funktion
wird dann durch die Methode test set der XMLHandler-Klasse geprüft, ob diese
Komponente überhaupt schon auswählbar ist. Falls das nicht der Fall ist, kommt
eine Fehlermeldung, die aussagt, welche Komponente zuerst gewählt werden soll.
Ist das Bauteil aber an der Reihe, so werden in der display-Funktion die entsprechenden
Informationen, basierend auf schon vorher ausgewählten Komponenten,
aus der Datenbank ausgelesen. Mit den Methoden der Elternklasse display head
und display footer werden dann nur kompatible Bauteile dargestellt.
6.5.2 Event: Auswahl
Nachdem alle kompatiblen Bauteile auf dem Bildschirm angezeigt werden, klickt
der Nutzer auf die Schaltfläche Auswählen“. Die Main.php wird auch hier wieder
”
neu geladen, und die POST-Variable auswahl ist gesetzt. Dadurch wird die Methode
handle choice click in der EventHandler Klasse aufgerufen. Hier wird dann
durch eine if-Abfrage getestet, ob der Artikel ausgewählt werden darf. Ist das
nicht der Fall, so passiert nichts weiter. Ist es erlaubt das Bauteil zu wählen, so
wird wieder die entsprechende Komponentenklasse aufgerufen, dessen Name immer
noch in der Session-Variable nav gespeichert ist. In der Funktion set session
wird die Session-Variable für die eigene Komponente gesetzt und, falls notwendig,
auch andere Variablen. Die nächste aufgerufene Funktion ist dann wieder display,
in der aufgrund der aktuellen Session-Variablen der Inhalt dargestellt wird. Ein
Beispiel hier für ist die Komponente Laufräder. Zu Anfang werden die beiden
Schaltgruppenmarken, Shimano und Campagnolo, angezeigt. Wird nun ein Laufradsatz
gewählt, der mit Shimano kompatibel ist, so sind nach dem Klick auf die
Auswahl-Schaltfläche nur noch Shimano-kompatible Laufräder zu sehen.
Diplomarbeit 74

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Abbildung 6.2: Ablauf beim Event Navigation
Diplomarbeit 75

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Abbildung 6.3: Ablauf beim Event Auswahl
Diplomarbeit 76

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
6.5.3 Event: Auswahl mit Zusatz
Diese Interaktion zwischen den Klassen ist etwas komplizierter als der normale
Auswahl-Ablauf. Allerdings gilt dies nur für die Komponenten Vorbau und Kurbelsatz.
Wird also in der Navigationsleiste einer der beiden Bauteile angeklickt, so
wird zwar auch die Komponententabelle dargestellt, allerdings mit einem Unterschied.
Der Name des Formulars, das die Auswahl-Schaltfläche beinhaltet, heißt
nicht mehr auswahl, sondern additional. So kann beim Anklicken des Auswahl-
Buttons in der Main.php registriert werden, dass nun die zusätzliche Tabelle mit
den jeweiligen Längen dargestellt werden soll. Der Ablauf vom Anklicken bis zum
Setzen der Variablen ist der gleiche wie bei der Auswahl, was in dem Diagramm die
Buchstaben A und B darstellen sollen. Nur wird nach der Auswahl nicht wieder
die Komponententabelle dargestellt, sondern die zusätzliche Tabelle. In der Event-
Handler Klasse kommt die Methode handle additional click zum Einsatz, die
ebenfalls die entsprechende Komponentenklasse aufruft. Dort wird dann mit Hilfe
der Funktionen display head und display footer die Tabelle mit den Längen
dargestellt. Hier heißen dann die Formulare der Auswahlfelder wieder auswahl, so
dass alles wieder den gewohnten Ablauf annehmen kann.
Diplomarbeit 77

KAPITEL 6. DAS PROGRAMM AUS SICHT DES ENTWICKLERS
Abbildung 6.4: Ablauf beim Event zusätzliche Auswahl
Diplomarbeit 78

Kapitel 7
Zusammenfassung und Ausblick
In den vorherigen Kapiteln wurden ausführlich die Klassen, die PHP Dateien, die
MySQL Datenbank und deren Inhalt, und dessen Zusammenspiel vorgestellt. Außerdem
gab es in einem Kapitel einen Überblick, wie der Nutzer den Konfigurator
sieht. In einem weiteren Kapitel wurde das Renn- bzw. Triathlonrad besprochen,
so wie die Abhängigkeiten zwischen den Komponenten. Zu Beginn gab es noch die
Überlegung, ob die Programmiersprache Java oder PHP für ein solches Projekt
geeigneter wären.
In diesem Kapitel möchte ich noch einmal zusammenfassen, was der Konfigurator
leistet, und inwieweit das vorgegebene Ziel erreicht wurde. Im nächsten Abschnitt
wird angesprochen was an dem Konfigurator zusätzlich implementiert werden
muss, damit daraus ein kommerzielles Produkt werden kann. Schließlich wird
noch ein persönliches Fazit gezogen.
7.1 Zusammenfassung
Wie in der Einleitung beschrieben, war es vorgegeben so kostengünstig wie möglich
einen Konfigurator für Renn- und Triathlonräder zu erstellen. Die Mittel, die zum
Programmieren verwendet wurden, entsprachen diesem Kriterium, da hauptsächlich
Open Source und/oder freie Programme verwendet wurden. Der Rechner, auf dem
Diplomarbeit 79

KAPITEL 7. ZUSAMMENFASSUNG UND AUSBLICK
der Konfigurator entwickelt wurde, war ein handelsüblicher Desktop Computer
mit Windows R○ XP als Betriebssystem. Darauf wurde dann ein Apache Server installiert,
ebenso wie ein PHP Interpreter, die beide frei im Internet verfügbar sind.
Auch die MySQL Datenbank lässt sich kostenlos herunterladen. Somit entfallen
die Kosten für Lizenzgebühren der essentiellen Programme. Auch die Lizenz für
die PHP Entwicklungsumgebung PHPEdit ist unter Angabe des Namens und einer
E-Mail Adresse kostenfrei erhältlich.
Probleme gab es allerdings mit dem Webserver, der den Konfigurator unter der
URL http://www.radtraum.de im Internet verfügbar machen sollte. Offensichtlich
gab es Kompatibilitätsprobleme zwischen den verschiedenen PHP und
MySQL Versionen. Doch diese konnten jedoch durch kleinere Workarounds“ behoben
werden.
”
Ein weiteres gefordertes Kriterium war, dass ein Nutzer nur Komponenten wählen
kann, die sich tatsächlich zusammenbauen lassen. So soll am Ende sichergestellt
sein, dass der Kunde ein funktionsfähiges Wunsch-Rad erstellt. Diese Forderung
war erwartungsgemäß die am schwierigsten umzusetzende. Nicht nur, dass zuerst
Komponentengruppen identifiziert werden mussten (vgl. Seite 10), sondern auch
deren Zusammenspiel und Abhängigkeiten untereinander herausgearbeitet werden
sollten. Das nahm einen nicht unerheblichen Teil des Projektes ein. Danach mussten
die erarbeiteten Daten mittels PHP in eine benutzerfreundliche Form gebracht
werden.
Dies war ein Grund, warum gegen eine assistierte Konfiguration, und für eine (relativ)
freie Wahl der Reihenfolge entschieden wurde. Allerdings verkomplizierte
diese, im Nachhinein gefällte Entscheidung, die Erstellung des Konfigurators. Es
mussten alle möglichen Fehler“ des Nutzers erkannt und abgefangen werden, damit
der virtuelle Zusammenbau des Wunschrades in gewünschte Bahnen gelenkt
”
wird.
Vergleicht man diesen Konfigurator mit anderen im Internet befindlichen Rad-
Konfiguratoren, so muss festgestellt werden, dass der in diesem Projekt Erstellte
recht fortschrittlich ist, da es auf manchen Seiten z.B. möglich ist, wahllos
Komponenten einzutragen, ohne darauf zu achten, ob diese auch zusammenpassen
[NR05]. Dennoch sollte zusätzlich eine Funktion implementiert werden, die nicht
Diplomarbeit 80

KAPITEL 7. ZUSAMMENFASSUNG UND AUSBLICK
einmal führende Automobilhersteller in ihren Konfiguratoren zur Verfügung stellen.
Ein so genannter Showroom“ sollte erstellt werden, so dass es für den Nutzer
”
möglich ist, bis zu drei verschiedene Fahrräder zu erstellen, und dann die einzelnen
Zusammenstellungen nebeneinander zu betrachten. Auch dieses wurde erfolgreich
realisiert, nachdem ein paar Probleme überwunden wurden, z.B. wie diese Daten
die ganze Zeit erhalten bleiben, ohne die Datenbank zu nutzen.
Eine weitere Eigenschaft des Programms, die aber nicht vorgegeben war, ist der
relativ generische Aufbau, mit dem ein Programmierer innerhalb kurzer Zeit einen
neuen Konfigurator für ein komplett anderes Produkt erstellen kann. Der arbeitsintensivere
Teil wäre natürlich das Identifizieren der Komponenten und der
Abhängigkeiten zwischen diesen. Ebenso müsste schon eine entsprechend erstellte
Datenbank vorhanden sein, bevor sich das Programm umgestalten lässt. Dazu
muss aber im Grunde nur eine vergleichbare XML-Datei erstellt und die dann
bekannten Abhängigkeiten in den Komponentenklassen implementiert werden.
Zusammengefasst bleibt zu sagen, dass das Projekt erfolgreich abgeschlossen wurde,
so dass der Auftraggeber, die Firma all4triathlon.com, sehr zufrieden mit dem
Ergebnis ist.
7.2 Ausblick
Da dieser Konfigurator zurzeit nur einen Prototypen darstellt, sind selbstverständlich
noch Verbesserungen möglich und notwendig, bevor dieser einen kommerziellen
Einsatz hat. Dennoch ist der Konfigurator voll funktionsfähig. Das heißt, alle
Funktionen, über die das Programm auch im kommerziellen Einsatz verfügen sollte,
sind schon vorhanden. Die Verbesserungen beziehen sich in erster Linie auf den
Bereich, der für den Nutzer relativ unerheblich ist.
Die wohl größte und wichtigste zukünftige Implementierung ist die Erstellung eines
Backends. Das derzeit eingesetzte System ist sehr rudimentär und diente dazu die
Datenbank zu füllen, oder zu löschen. In einem kompletten Backend sollen nicht
nur komfortable Datenbankfunktionen enthalten sein, sondern auch ein System
zum Einpflegen und Warten von neuen Komponenten. Doch diese Erstellung war
Diplomarbeit 81

KAPITEL 7. ZUSAMMENFASSUNG UND AUSBLICK
nicht die Aufgabe des Projekts, und das vorhandene Backendsystem erfüllte alle
Funktionen, die während der Entwicklung des Konfigurators notwendig waren.
Ein weiteres, während der Entwicklung nicht behandeltes Problem, ist die Kompatibilität
zwischen den verschiedenen Browsern. Zurzeit ist das Programm auf
Mozilla Firefox und Opera optimiert. Entsprechende Anpassungen für den Microsoft
Internet Explorer, Konqueror oder auch Safari müssten folgen. Weitere Verbesserungen
in der Darstellung sind generell gefragt, aber insbesondere muss die
Anzeige für kleinere Bildschirme angepasst werden, da während der Entwicklungszeit
eine relativ hohe Auflösung benutzt wurde. Schließlich könnte das Programm
so geändert werden, dass Templates benutzt werden, und die Gestaltung somit
unabhängig von der Rule-Engine“ ist.
”
7.3 Schlusswort
Um ein Fazit zu ziehen, möchte ich zuerst anmerken, dass das Diplomarbeitsprojekt
eine Herausforderung war, in dem Sinne, dass ohne auf einer Grundlage aufzubauen,
ein funktionierender Prototyp entstanden ist. Manches Problem während
der Entwicklung war nicht so einfach zu lösen, doch es hat immer Spaß gemacht, an
diesem Projekt zu arbeiten. Außerdem konnte ich durch die Erstellung des Konfigurators
meine Fähigkeiten in PHP, HTML und auch JavaScript weiter vertiefen,
was sich im Berufsleben als nützlich erweisen wird. Hinzu kommt, dass ich nun Gewissheit
habe ein Projekt dieser Größe eigenständig organisieren und realisieren
zu können.
Diplomarbeit 82

Anhang A
Tables der Datenbank
In diesem Teil des Anhangs werden alle Tables der Datenbank abgebildet. Der
Spaltenname ist in den Tabellen so wiedergegeben, wie er auch in der Datenbank
abgelegt ist. Deshalb sind auch keine Umlaute zu finden, da die Namenskonvention
von MySQL diese nicht erlaubt. Die Tabellen enthalten jeweils eine Spalte für den
Spaltennamen, die Eigenschaften dieser, und eine kleine erklärende Bemerkung.
Diplomarbeit 83

ANHANG A. TABLES DER DATENBANK
TABLE Rahmen
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
rahmenhoehe TINYINT(2) UNSIGNED NOT NULL DEFAULT 0 wichtiges Maß
gabelaufnahme FLOAT NOT NULL DEFAULT 0 Maße in mm, ≥100=schon vorhanden
steuersatz TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=vorhanden, 1=nicht vorhanden
sattelrohr FLOAT NOT NULL DEFAULT 0 Maße in mm, ≥100=schon vorhanden
tretlager FLOAT NOT NULL DEFAULT 0 Maße in mm
TABLE Steuersatz
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
gabelschaft FLOAT NOT NULL DEFAULT 0 üblich in Zoll, hier in mm
Diplomarbeit 84

ANHANG A. TABLES DER DATENBANK
TABLE Gabel
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
gabelschaft FLOAT NOT NULL DEFAULT 0 üblich in Zoll, hier in mm
laenge SMALLINT UNSIGNED NOT NULL DEFAULT 0 relevant f. Rahmenhöhe
TABLE Vorbau
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
gabelaufnahme FLOAT NOT NULL DEFAULT 0 Durchmesser des Gabelschafts, in mm
lenkeraufnahme FLOAT NOT NULL DEFAULT 0 Durchmesser des Lenkers, in mm
laenge1 TINYINT UNSIGNED NOT NULL DEFAULT 0 zw. 70 u. 140 mm
. . . . . . . . .
laenge9 TINYINT UNSIGNED NOT NULL DEFAULT 0 zw. 70 u. 140 mm
winkel TINYINT NOT NULL DEFAULT 0 zw. -17 ◦ und 17 ◦
flip TINYINT(1) NOT NULL DEFAULT 0 0 = nicht drehbar, 1 = drehbar
Diplomarbeit 85

ANHANG A. TABLES DER DATENBANK
TABLE Lenker
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
lenkerdurchm FLOAT NOT NULL DEFAULT 0 Durchmesser des Lenkers, in mm
breite TINYINT UNSIGNED NOT NULL DEFAULT 0 Breite (Mitte-Mitte)
lenkerart TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=Rennrad, 1=Tri, ≥2=beide
aeroaufsatz TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=N/A, 1=möglich, ≥2=dabei
TABLE Aeroaufsatz
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
lenkerklemm FLOAT NOT NULL DEFAULT 0 Durchmesser des Lenkers, in mm
Diplomarbeit 86

ANHANG A. TABLES DER DATENBANK
TABLE Laufraeder
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
durchmesser SMALLINT UNSIGNED NOT NULL DEFAULT 0 Durchmesser des Laufrads in mm
reifenart TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=Schlauch-, ≥1=Drahtreifen
nabe TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=Shimano, ≥1=Campa kompatibel
TABLE Reifen
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
durchmesser SMALLINT UNSIGNED NOT NULL DEFAULT 0 Durchmesser des Laufrades, in mm
breite TINYINT UNSIGNED NOT NULL DEFAULT 0 Breite des Reifens: 19mm - 25mm
reifenart TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=Schlauch-, ≥1=Drahtreifen
Diplomarbeit 87

ANHANG A. TABLES DER DATENBANK
TABLE Kurbelsatz
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
kettenblatt TINYINT UNSIGNED NOT NULL DEFAULT 2 1=compact, 2=normal, 3=3er Blatt
zaehne vorne TINYINT UNSIGNED NOT NULL DEFAULT 0 Anzahl Zähne auf dem großen Blatt
zaehne mitte TINYINT UNSIGNED Nur bei 3er Kettenblätter
zaehne hinten TINYINT UNSIGNED NOT NULL DEFAULT 0 Anzahl Zähne auf dem kleinen Blatt
laenge1 FLOAT NOT NULL DEFAULT 0 kürzeste Länge der Kurbel
. . . . . . . . .
laenge7 FLOAT NOT NULL DEFAULT 0 längste Länge der Kurbel
kompatibel TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=Shimano, 1= Campa, ≥2=beide
TABLE Bremsen
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
Diplomarbeit 88

ANHANG A. TABLES DER DATENBANK
TABLE Schaltgruppe
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
kettenblatt TINYINT UNSIGNED NOT NULL DEFAULT 2 1=compact, 2=normal, 3=3er Blatt
hersteller TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 1=Shimano, ≥1=Campagnolo
lenkerart TINYINT(1) UNSIGNED NOT NULL DEFAULT 0 0=normal, ≥1=Aerolenker
kassette min TINYINT UNSIGNED NOT NULL DEFAULT 0 Anz. Zähne kleinstes Ritzel
kassette max TINYINT UNSIGNED NOT NULL DEFAULT 0 Anz. Zähne größtes Ritzel
TABLE Pedale
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
Diplomarbeit 89

ANHANG A. TABLES DER DATENBANK
TABLE Sattelstuetze
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
laenge SMALLINT UNSIGNED NOT NULL DEFAULT 0 verstellbare Länge der Stütze, in mm
durchmesser FLOAT UNSIGNED NOT NULL DEFAULT 0 Durchmesser des Sattelrohrs, in mm
TABLE Sattel
Spaltenname Eigenschaften Bemerkung
artikelnummer CHAR(6) PRIMARY KEY künstlicher eindeutiger Schlüssel
gewicht SMALLINT UNSIGNED NOT NULL DEFAULT 0 das Gewicht der Komponente
name VARCHAR(100) NOT NULL der Name der Komponente
beschreibung TEXT NOT NULL eine schöne Beschreibung
preis FLOAT NOT NULL DEFAULT 0 das Wichtigste
bild VARCHAR(40) NOT NULL URL zu einem Artikelbild
Diplomarbeit 90

Anhang B
Screenshots
Abbildung B.1: Die Startseite
Diplomarbeit 91

ANHANG B. SCREENSHOTS
Abbildung B.2: Konfigurator für Triathlonräder
Diplomarbeit 92

ANHANG B. SCREENSHOTS
Abbildung B.3: Konfigurator für Rennräder
Diplomarbeit 93

Quellenverzeichnis
[Bik06]
MAXX Bikes. Bike Configurator.
http://www.maxx.de/fr inhalt bikes road.htm, 2006.
[Bra05] Christian Braun. PHP5 für Dummies. Wiley-VCH, 2005.
[Cat06]
[Con04]
[Gle03]
[Hat02]
Java Catalog. Java Enterprise System Lizenz.
http://catalog.sun.com/, 2006.
Contentmanager.de. Case study: Der wechsel von Java zu PHP bei der
Augsburger Allgemeinen Zeitung.
http://www.contentmanager.de/community/forum/4/1901/1912.html,
2004.
Daniel Gleim. Multimedia-Sprachen und Standarts im Internet.
www-ra.informatik.uni-tuebingen.de/lehre/ws02/pro internet
ausarbeitung/proseminar gleim ws02.pdf, 2003.
Jens Hatlak. PHP Hypertext Preprocessor.
http://jens.hatlak.de/php.php4, 2002.
[Hom06a] Java Homepage. Connected Limited Device Configuration.
http://java.sun.com/products/cldc/overview.html, 2006.
[Hom06b] Java Homepage. Java SE Hotspot.
http://java.sun.com/javase/technologies/hotspot.jsp, 2006.
[IBM06]
IBM. Ibm Software - DB2 Product Family.
http://www-306.ibm.com/software/data/db2/, 2006.
Diplomarbeit 94

LITERATURVERZEICHNIS
[ID06]
[Ihn06]
[Ind06]
[Mor02a]
[Mor02b]
[Nor03]
[NR05]
IST-Dresden. Java Technologie.
http://www.ist-dresden.de/technology/java.html, 2006.
Oliver Ihns. Umkehr der Beweislast.
JavaMagazin.de, 2006.
Indexpage.ch. Web-sprachen.
http://www.indexpage.ch/web-codes/html/praxis/websprachen.php,
2006.
Rene Morschhauser. Nachteile von PHP.
http://www.mathematik.uni-ulm.de/sai/ws01/portalsem/rene/
internetportale/node27.html, 2002.
Rene Morschhauser. Vorteile von PHP.
http://www.mathematik.uni-ulm.de/sai/ws01/portalsem/rene/
internetportale/node26.html, 2002.
D’Arcy Norman. PHP vs. Java commentary from Raible.
http://www.darcynorman.net/2003/08/24/php-vs-java-commentaryfrom-raible,
2003.
Neon-Radsport. Rennrad Konfigurator.
http://www.neon-radsport.de/konfigurator.php?type=Rennrad, 2005.
[Ora06] Oracle. Oracle Database 10g.
http://www.oracle.com/technology/products/database/oracle10g/
index.html, 2006.
[osC06]
[Tut05]
osCommerce. Deutsche osCommerce Homepage.
http://www.oscommerce.de/, 2006.
Tutorials.de. Zugriff auf eine Klasseninstanz.
http://www.tutorials.de/forum/php/212138-zugriff-auf-eineklasseninstanz-innerhalb-einer-funktion-einer-anderen-klasse.html,
2005.
Diplomarbeit 95

LITERATURVERZEICHNIS
[Typ06]
[WC04]
[Wik06a]
Typo3. What is Typo3?
http://typo3.com/About.1231.0.html, 2006.
Webwork-Community.net. Java und Web.
http://www.webwork-community.net/posting4895 47 0.html, 2004.
Wikipedia.de. Geschichte Javas.
http://de.wikipedia.org/wiki/Java (Technologie)#Geschichte Javas,
2006.
[Wik06b] Wikipedia.de. Geschichte von PHP.
http://de.wikipedia.org/wiki/PHP/FI#Geschichte, 2006.
[XF04]
XHTML-Forum. Vorteile Java gegenüber PHP?
http://xhtmlforum.de/288066-post14.html, 2004.
Für die Entwicklung verwendete Literatur
[Ögg05] Michael Kofler ; Bernd Öggl. PHP 5 & MySQL 5. Addison-Wesley, 2005.
[Hir04] Jens Ferner ; Elena Hirte. PHP5 Rezepte. Data Becker, 2004.
[Hir05] Elena Hirte. PHP5 & MySQL. Data Becker, 2005.
[Kra04] Jörg Krause. PHP 5 - Grundlagen und Profiwissen. Hanser, 2004.
[Käu04] Mechthild Käufer. (X)HTML. Data Becker, 2004.
[McC04] Bill McCarty. PHP-Grundlagen. mitp, 2004.
[Nef03] Stefan Münz ; Wolfgang Nefzger. JavaScript - Referenz. Franzis, 2003.
[Sel06]
SelfHTML. SelfHTML - HTML-Dateien selbst erstellen. de.selfhtml.org,
2006.
[Tra05] David Sklar ; Adam Trachtenberg. PHP-Kochbuch. O’Reilly, 2005.
[Zed02] Dirk Zedler. Das Rennrad im Selbstaufbau. Delius Klasing, 2002.
Diplomarbeit 96