Embed Size (px)
Citation preview
Effizientere PHP Entwicklung mit Zend Studio
Richtiger Umgang mit wichtigen Funktionen
Projektarbeit Nr.: 1
vorgelegt am: 07.10.2010
von:
Matrikelnummer:
Berufsakademie: Berufsakademie Gera
Weg der Freundschaft 4a
07546 Gera
Studienbereich: Technik
Studiengang: Praktische Informatik
Kurs:
Ausbildungsstätte: dotSource GmbH
Leutragraben 1
07743 Jena
Betreuer: Christian Otto Grötsch MBE
II
Inhaltsverzeichnis
Inhaltsverzeichnis ............................................................................ ii
Abbildungsverzeichnis ...................................................................... iv
Abkürzungsverzeichnis ...................................................................... v
1 Einleitung............................................................................... 6
1.1 Integrierte Entwicklungsumgebungen, eine oft verkannte Unterstützung .... 6
1.2 Zielsetzung der Arbeit ................................................................ 7
2 Entwicklungsumgebungen und deren wachsende Relevanz .................. 8
2.1 Aufbau und Verwendung .............................................................. 8
2.2 Evolutionsstufen ....................................................................... 8
2.3 Aktueller Stand für PHP ............................................................... 9
2.4 Zend Studio - Kurzübersicht ......................................................... 10
3 Arbeiten mit dem Zend Studio .................................................... 11
3.1 Aufbau des Programms ............................................................... 11
3.2 Funktionserweiterung mithilfe des Plugin Systems .............................. 12
3.3 Projekt anlegen und Workspace Einstellungen treffen .......................... 13
3.4 Anwendung von Standardfunktionen ............................................... 14
3.5 Dokumentationen anfertigen mit PHPDocumentor .............................. 15
3.6 Formatierungen einhalten mit PHP CodeSniffer ................................. 19
3.7 Teamarbeit mittels Subversion ..................................................... 21
3.8 Integration von Subclipse in Zend Studio.......................................... 22
3.9 Repository aktivieren und auschecken ............................................ 22
3.10 Prozedur des SVN Merge-, Update-, und Eincheckvorgangs .................... 23
3.11 Zend Debugger ........................................................................ 25
3.12 Installation und Konfiguration des Debuggers .................................... 26
3.13 Verwendung des Debuggers ......................................................... 27
3.14 Abschließende Worte zu Erweiterungen ........................................... 30
4 Fazit .................................................................................... 31
Anlagenverzeichnis .......................................................................... 32
Anlage A: Plugin Downloadlinks ........................................................... 33
III
Anlage B: Wichtige Shortcuts .............................................................. 34
Anlage C: Wichtige PHPDocumentor Tags ............................................... 36
Literaturverzeichnis ......................................................................... 37
Glossar ......................................................................................... 38
Ehrenwörtliche Erklärung .................................................................. 41
IV
Abbildungsverzeichnis
Abbildung 1 PHP IDE Vergleich. Mit Änderungen entnommen aus: [Goo09] .......... 10
Abbildung 2 Perspective mit drei Views ................................................... 12
Abbildung 3 Content Assist .................................................................. 15
Abbildung 4 PHPDocumentor Methoden-Tag .............................................. 17
Abbildung 5 PHPDocumentor Methoden-Tag .............................................. 18
Abbildung 6 PHP CodeSniffer - Einstellungen ............................................. 20
Abbildung 7 PHP CodeSniffer - Editorintegration von Fehlern ......................... 21
Abbildung 8 Team-Synchronisation mit SVN-Dateivergleich ............................ 24
Abbildung 9 Firefox mit Zend Toolbar ..................................................... 26
Abbildung 10 ZendDebugger – Profiler ..................................................... 28
Abbildung 11 Debug Perspective ............................................................ 29
V
Abkürzungsverzeichnis
CSS Cascading Style Sheets
HTML Hypertext Markup Language
IDE Integrated Software Environment
JS JavaScript
PDT PHP Development Tool
PHP Hypertext Preprocessor
SEU Softwareentwicklungsumgebung
SVN Subversion
UML Unified Modeling Language
6
1 Einleitung
Einige der wichtigsten Ziele bei der Programmierung von Software sind es, diese
fehlerfrei, schnell und sauber, d.h. gut strukturiert und leserlich, zu entwickeln. Je
größer ein Projekt, je mehr Entwickler daran beteiligt oder auch je weniger Zeit
dafür eingeplant ist, desto stärker wird die Nachfrage nach effizienten Hilfen bei
der Entwicklung.
1.1 Integrierte Entwicklungsumgebungen, eine oft verkannte Unterstützung
„Eine sehr nahe liegende Idee ist hier, die entwickelten Methoden selbst wieder
als Software zu realisieren, d.h. spezielle Programme, sogenannte (Soft-)
Werkzeuge zu entwickeln, die den Softwareentwickler bei seiner Arbeit
unterstützen.“1 Dieser Gedanke führte zur Entwicklung sogenannter integrated
software environments (IDE), welche dem Entwickler die von ihm oft verwendeten
oder auch dringend benötigten Funktionen in einer einheitlichen Schnittstelle zur
Verfügung stellen. Die Verbreitung solcher Programme ist im Laufe der Jahre stark
gewachsen, woraufhin sich viele Referenzprodukte für die jeweiligen Sprachen
herausgebildet haben. Eines dieser Produkte ist das Zend Studio für die
Scriptsprache Hypertext Preprocessor (PHP).
Jedoch wird häufig die Mächtigkeit solch eines Werkzeugs von Entwicklern
unterschätzt, bzw. sieht man nicht die Notwendigkeit sich in die Software
einzuarbeiten. Dies kann eine ineffiziente Arbeit mit der unterstützenden Software
zur Folge haben.
1 [Eng98], S. 7
7
1.2 Zielsetzung der Arbeit
Die dotSource GmbH, in welcher der Autor arbeitet, hat sich auf den Bereich des
Social Commerce ausgerichtet. Aufgrund dieser Spezialisierung verwendet sie in
der Umsetzung gewünschter Funktionen unter anderem auch die Sprache PHP. Als
Firma mit großen Projekten in der Softwareentwicklung ist ihr die effiziente
Entwicklung von Software ein wichtiger Faktor, welcher immer wieder einer
Leistungssteigerung unterzogen wird.
Die folgende Praxisarbeit wird sich mit dem Zend Studio, einer
Entwicklungsumgebung für PHP, befassen. Ziel ist es dem Leser mit dieser Arbeit
ein Dokument zu liefern, was ihm in der ersten Hälfte die Bedeutung von IDEs
näher bringt und ihm anschließend die Arbeit mit der genannten
Entwicklungsumgebung praxisnah darlegt. Dabei werden verschiedene, für die
Entwicklung relevante Funktionalitäten und Verfahrenswege erläutert und
dokumentiert. Hierbei wird sich diese Arbeit mit einigen wenigen, jedoch sehr
wichtigen Funktionen auseinandersetzen. Deren Auftreten wird sich an den
Arbeitsprozessen in einem Softwareunternehmen orientieren. Da in dieser Arbeit
nur auf ein Teil der Funktionspalette und Zusatzprogramme der IDE eingegangen
werden kann, sei der Leser hier bereits bei Bedarf auf weiterführende Lektüre
verwiesen.
8
2 Entwicklungsumgebungen und deren wachsende
Relevanz
Im ersten Teil der Arbeit soll es theoretischer Art um
Softwareentwicklungsumgebungen (SEU) gehen. Es wird konkret auf die
Verwendung und die Entwicklung der Programme eingegangen.
2.1 Aufbau und Verwendung
Man kann eine Entwicklungsumgebung im Wesentlichen in die beiden Bereiche
Funktionalität und Benutzerschnittstelle gliedern. Die Funktionalität repräsentiert
dabei den Umfang der Werkzeuge, welche verwendet werden können. Letzterer
stellt die Art und Weise der Anwendung von den Funktionen dar. Die Eingabe kann
sich dabei von Kommandozeilen bis zu kontextsensitiven Auswahlboxen erstrecken.
Die Ausgabe geschieht heute meist grafisch (z.B. über den Editor). Des Weiteren
können Funktionen in einzelnen Bereichen des Bildschirms getrennt dargestellt
werden, was einer besseren Übersicht zugute kommt. SEUs enthalten i.d.R
programmiersprachenabhängige Funktionen. Einige Funktionalitäten, wie z.B. das
Syntax Coloring und die Content Assist Funktion, sind jedoch in den meisten
Umgebungen enthalten. Sie unterscheiden sich nur durch die sprachabhängige
Verwendung in den einzelnen SEUs. Hinzu kommen meist Zusatzfunktionen, die
nicht direkt der Entwicklung, sondern der Pflege des Projektes, dienen. Dieses
wären z.B. Dokumentationsanfertigungen, welche über die IDE realisiert werden
können.
2.2 Evolutionsstufen
Als erste Vorreiter der heutigen SEUs könnten beispielsweise Compiler und Linker
genannt werden. Sie stellen dem Nutzer bereits Funktionen in vereinfachter Form
9
bereit. Jedoch ist die Benutzerschnittstelle und die benötigten Kommandos bei der
Verwendung unterschiedlicher Programme meist nicht einheitlich. Zusätzlich ist
auch der Funktionsumfang bei beispielsweise gleichen Compilern unterschiedlicher
Entwickler nicht gleichwertig. Der wachsenden Relevanz einer einheitlichen
Verwendung folgten daher Softwareproduktionsumgebungen, welche diese
Vereinheitlichung anbieten. Zusätzlich wurden zu dieser Zeit bereits
Forschungsprojekte in Leben gerufen, die eine Weiterentwicklung solcher
Umgebungen fördern.2 In weiteren Evolutionsstufen wurde dann zumeist der
Funktionsumfang erweitert, sodass die Entwicklungsumgebung eine größere
Bandbreite an unterstützenden Arbeiten anbietet. Heute sind die SEUs in der
Bedienung ausgereift und stellen die wichtigsten Funktionen integriert in ihrem
Funktionskern zur Verfügung, teilweise sogar maschinenunabhängig (Zend Studio
selbst ist solch eine plattformunabhängige Entwicklungsumgebung).
2.3 Aktueller Stand für PHP
Im PHP Sektor haben sich im Laufe der Jahre einige Programme durchgesetzt.
Dabei ist zu beachten, dass PHP i.d.R. mittels eines Interpreters in Form eines
Webservers eingesetzt wird. Dies bedeutet, dass nicht die Skriptsprache alleinig,
sondern auch Hypertext Markup Language (HTML) und JavaScript (JS) bei der
Entwicklung zum Einsatz kommen. Die softwareseitige Entwicklungsunterstützung
aller drei Sprachen ist ein nicht zu unterschätzendes Kriterium bei der Platzierung
einer IDE. Drei der wichtigsten Vertreter sind unabhängige Weiterentwicklungen
der Software Eclipse: Zend Studio, PHP Development Tool (PDT) und Aptana. Des
Weiteren weiteren wäre noch NetBeans zu nennen, welches, ebenso wie Eclipse,
ursprünglich zur Entwicklung mit Java verwendet wird. Die nachfolgende Abbildung
zeigt einen Auszug der Unterschiede zwischen den einzelnen IDEs. Die Vollständige
Liste kann in Anlage G betrachtet werden.
2 [Eng98], S. 112 ff.
10
Abbildung 1 PHP IDE Vergleich. Mit Änderungen entnommen aus: [Goo09]
2.4 Zend Studio - Kurzübersicht
Zend Studio ist eine Weiterentwicklung des PDT Projektes. Im Gegensatz zu diesem
ist es kostenpflichtig, bietet jedoch einige Verbesserungen, wie z.B. die Integration
des ZendDebuggers. Es ist spezialisiert auf die Entwicklung mit HTML, JS, Cascading
Style Sheets (CSS) und vor allem PHP. Es bietet verschiedene, für die eben
genannten Sprachen nutzvolle, Funktionen, welche die Effektivität von
Softwareentwicklungen erheblich steigern können. Damit dieser Leistungsgewinn
jedoch auch nutzbar sein kann, sollten verschiedenste Abläufe, Funktionen und
Eigenschaften der Software bekannt und anwendbar sein.
11
3 Arbeiten mit dem Zend Studio
Das nun folgende Kapitel wird sich mit dem Zend Studio in der Praxis beschäftigen.
Die dabei genannten Abläufe wurden anhand der Version 7.2 erstellt. Es werden
Funktionalitäten in einer praxisrelevanten Reihenfolge erläutert.
3.1 Aufbau des Programms
Das Programm ermöglicht es dem Entwickler seine Funktionen mittels sogenannten
Perspectives und Views strukturell zu trennen. Ersteres, die Views, dienen dazu
große Funktionsblöcke in eigenen Ansichtseinstellungen zu nutzen. Beispielsweise
kann man das Debuglayout völlig von der Entwicklungsansicht getrennt gestalten.
Die Views dienen der Anzeige einzelner Funktionen einer Perspective. Diese lassen
sich bei Bedarf anzeigen und sind frei im Programm per verschiebbar. Das folgende
Bild zeigt die PHP-Perspective mit drei vertikalen Views.
12
Abbildung 2 Perspective mit drei Views
3.2 Funktionserweiterung mithilfe des Plugin Systems
Zend Studio bietet die komfortable Möglichkeit der Erweiterung über Plugins. Die
Installation kann dabei auf zwei Arten durchgeführt werden. Zum Einen werden die
geladenene Plugindateien in den Installationsordner von Zend Studio händig
eingepflegt oder sie werden über den integrierten Installationsmanager geladen.
Der Manager kann in der Menüleiste unter Help → Install New Software...
aufgerufen werden. Darin wird die URL des Plugins eingegeben und die IDE
kümmert sich selbständig um Download und Einrichtung. Es sei noch erwähnt, dass
in der Menüleiste unter Help → Check For Updates nach Aktualisierungen der
bereits installierten Funktionen geschaut werden kann. Nach der Installation und
einem Neustart ist die Erweiterung i.d.R. bereits voll einsatzfähig. Möchte man
dennoch Änderungen vornehmen, so ergänzen sich dafür meist neue Einträge unter
13
den Workspace-/ Projekteinstellungen, welche zur Anpassung des Plugins
verwendet werden können.
3.3 Projekt anlegen und Workspace Einstellungen treffen
Softwareentwicklungen finden innerhalb eines sogenannten Projektes statt. In solch
ein Projekt werden die später folgenden Skripte angezeigt. Zend Studio bietet dazu
die Möglichkeit in einem Workspace, sprich einem Ausgangsverzeichnis für
abzulegende Daten, ein oder mehrere Projekte anzulegen und über seine Explorer -
Perspektive zu verwalten. Dazu wählt man zuerst in der oberen Menüleiste unter
File → Switch Workspace → Other ein gewünschtes Verzeichnis aus. Im nächsten
Schritt legt man mit einem Klick auf File → New → Project und der Eingabe eines
Projekttypen und -namens ein neues Projekt an. Mit dem Typen aktiviert das
Programm intern verschiedene Funktionen, wie bspw. Syntax Coloring, auf welche
im Kapitel Anwendung von Standardfunktionen noch kurz eingegangen wird. Hier sei
vorerst nur gesagt, dass Zend Studio, da es für PHP gedacht, hauptsächlich unter
Verwendung von PHP Projekten genutzt wird. Mit diesen zwei Angaben ist Eclipse
zum Verwenden seiner Funktionen bereit und kann zum Entwickeln verwendet
werden.
Wenn nun der Bedarf an Änderungen des Eclipseverhalten oder -aussehens, welches
über das Ausrichten von Views hinaus geht, besteht, so können weitere gewünschte
Einstellungen für das Projekt oder den Workspace getroffen werden. Die
zugehörigen Einstellungen sind zu finden unter Window → Preferences. In diesem
Eigenschaftenfenster lassen sich sämtliche, von Eclipse vorgesehene, Einstellungen
ändern. Des Weiteren existieren noch Projekteinstellungen. Zu finden sind diese
unter Project → Properties. Die Einstellungen des Projektes sind vererbte des
Workspace. Weshalb man sämtliche Einstellungen innerhalb eines Projektes
unabhängig vom Workspace konfigurieren kann. Vom Anschalten von
14
Sprachvalidatoren, über das Einstellen von Editorfarben, bis hin zur Änderung von
Shortcuts. Für genauere Ausführungen sei hier auf den Zend Studio User Guide im
Anhang verwiesen.
3.4 Anwendung von Standardfunktionen
Standardmäßig liefert Zend Studio bereits einige nützliche Funktionen. Einen
kurzen Überblick soll dieses Kapitel liefern.
Als Erstes ist das Syntax Coloring erwähnenswert. Es ermöglicht das visuelle
Erfassen von Methoden, Strings, Kommentaren und vielem Weiteren. Es wird
selbständig beim Öffnen einer Datei mittels PHP Editor – View verwendet.
Des Weiteren erweist sich im Praxisalltag der Content Assist als sehr nützlich.
Schreibt man einen Befehl, sei es eine PHP-Funktion, einen Klassennamen oder
eine Variable, so kann nach Tippen von einigen Buschstaben des Namens die
Tastenkombination Strg + Leertaste gedrückt werden um eine
Vervollständigungsliste von möglichen Namen des aktuell geschriebenen Wortes zu
öffnen. Die folgende Abbildung stellt ein solches Beispiel dar.
15
Abbildung 3 Content Assist
Hierbei wurde nach PHP Funktionen gesucht, welche mit dem Präfix array_
beginnen. Des Weiteren kann man erkennen, dass rechts neben den
Auswahlmöglichkeiten noch der PHPDoc der entsprechenden Methode angezeigt
wird. Dazu im nächsten Kapitel: Dokumentationen anfertigen mit PHPDocumentor mehr.
Weitere Funktionen sind beispielsweise das Validieren von HTML Fehlern in einer
Datei und dessen visuelle Ausgabe im PHP Editor, sowie das Refacturing von
Dateien mit einer globalen Änderung des Klassen-, Methoden- oder
Variablennamen. Das ausführliche Behandeln aller Funktionen würde jedoch den
Rahmen dieser Arbeit übersteigen, deswegen sei hier auf das Handbuch von Zend
Studio, welches unter Anlage D: Zend Studio 7.2 User Guide zu finden ist,
verwiesen.
3.5 Dokumentationen anfertigen mit PHPDocumentor
Eine der Wichtigsten Arbeiten eines Entwicklers stellt die Anfertigung von
Dokumentationen dar. Diese sind in jeder Entwicklungsphase von hoher Priorität zu
versehen, da sie die Wartbarkeit des Codes ungemein erleichtern. Es können je
nach Anforderung unterschiedliche Abstraktionsebenen zur Anfertigung verwendet
werden. Dazu gehören beispielsweise Syntax-Diagramme oder eben auch die
Dokumentation innerhalb des Quelltextes.
16
Vor der eigentlichen Implementierung des Codes befasst man sich mit der
Umsetzung, sodass hier bereits vor der Implementierung später auftretende
Probleme erkannt und nicht erst in abschließen Tests gefunden und behoben
werden müssen. Während des Programmierens helfen gesetzte Kommentare den
Code verständlich zu halten. Zu guter Letzt muss man die anfängliche
Dokumentation den entsprechenden, in der Umsetzung aufgetretenen Änderungen
abermals anpassen und so auf dem aktuellen Stand halten. Zend Studio bietet für
jeden dieser Schritte eine Unterstützung.
Für die Dokumentation des Codes bietet es sich an, den in Zend Studio integrierten,
PHPDocumentor zu verwenden. Mit diesem Programm lassen sich gewünschte
Klassen, deren Methoden und Variablen in einer HTML, PDF oder XML Übersicht
generieren. Ein weiterer Vorteil dieses Dokumentationsprogrammes besteht darin,
dass zusätzliche Kommentare zur Erläuterung von Klassen, Methoden und Variablen
verwendet werden können. Die dafür benötigten Kommentarzeichen sind /** zum
Öffnen und */ zum Schließen des Kommentars. Dieser baut sich aus einer Kurz- und
Langbeschreibung, sowie sogenannten DocBlock-Tags zusammen. In der folgenden
Abbildung wird die Verwendung eines solchen Kommentares gezeigt:
17
Abbildung 4 PHPDocumentor Methoden-Tag
Zuerst wird die Kurzbeschreibung angegeben. Sie wird durch ein Leerzeichen von
der Langbeschreibung getrennt. Als Letztes folgen die Tags. Sie werden mit einem
@ vorangestellt gestartet und dienen der Nennung von z.B. Parametern,
Rückgabewerten oder dem Autor. Wichtige Tags und deren Bedeutung können der
Tabelle in Anlage C: Wichtige PHPDocumentor Tags entnommen werden. Hat man
nun Klassen fertiggestellt und möchte sie mittels Übersicht zur Verfügung stellen,
so reicht ein Klick auf Project → Generate PHPDoc... und Angabe der zu
generierenden Dateien. In der folgenden Abbildung ist eine solche HTML Übersicht
eines Projektes zu sehen.
18
Abbildung 5 PHPDocumentor Methoden-Tag
In der Praxis stellt sich das ausschließliche dokumentieren von Code als nicht
ausreichend dar. Dafür bietet Zend Studio jedoch über sein Plugin System ebenfalls
Erweiterungen zur Verfügung, wie z.B. zur Modellierung des Projektes mit der
Unified Modeling Language (UML) über AmaterasUML oder ArgoEclipse. Beide bieten
die Möglichkeit Sequenz-, Klassen-, Aktivitäts- und Usecase Diagrammme zu
erstellen. Installiert werden sie über den Update- und Installationsmanager von
Eclipse. Es soll hier nicht weiter auf die entsprechenden Funktionen der einzelnen
Diagrammtypen eingegangen werden.
19
3.6 Formatierungen einhalten mit PHP CodeSniffer
Eine ebenso nicht unbetrachtliche Wichtigkeit in der Softwareentwicklung nimmt
die richtige Formatierung ein. Ihre Priorität liegt darin begründet, dass ein Einlesen
in die Entwicklung eines anderen Mitarbeiters leicht vonstattengehen sollte. Dies
kann betrachtlich verbessert werden, wenn in einem Projekt stets die gleiche
Formatierung verwendet wird, sodass das Schreiben eines Quelltextes einheitlich
gestaltet und übersichtlich zu lesen ist. Ein nützliches Plugin zur Gewährleistung
einer einheitlichen Quelltextformatierung stellt der PHP CodeSniffer dar. Installiert
werden kann er ebenfalls über den Installationsmanager von Zend Studio. Nach
erfolgreicher Installation findet sich nun in den Workspace Einstellungen ein neuer
Eintrag unter PHP Tools → PHP CodeSniffer. Hierin können verschiedene
Einstellungen zu den verwendeten Formatierungen getroffen werden. Dazu gehören
die Auswahl eines Formatierungsstandards und die genauere Anpassung dessen in
Form von Einstellungen wie Tabulatorweite oder zu ignorierende Sniffs. Die
nachfolgende Abbildung zeigt ein Beispiel der Einstellmöglichkeiten dieser
Optionen.
20
Abbildung 6 PHP CodeSniffer - Einstellungen
Nachdem nun diese Einstellungen getroffen wurden, muss der CodeSniffer in Zend
Studio noch aktiviert werden. In den Workspac Einstellungen unter Validation →
PHP CodeSniffer Validator kann dieser auf manuelle Validierung der
Formatierungen und / oder automatische Aktivität eingestellt werden. Erstere kann
im Kontextmenü der PHP – Perspective auf einzelne Dateien angewandt werden,
Letztere aktiviert sich selbständig nach Speicherung einer Quelltextdatei. Findet
der CodeSniffer Formatierungsfehler, so zeigt er diese visuell innerhalb der
21
fehlerhaften Quelldatei an. Die folgende Abbildung zeigt einen Ausschnitt eines
Formatierungsfehlers, bei welchem die Einrückung von mehrzeiligen Befehlen nicht
der aktivierten Formatierungsregel entspricht.
Abbildung 7 PHP CodeSniffer - Editorintegration von Fehlern
3.7 Teamarbeit mittels Subversion
Wird ein Projekt unter mehreren Entwicklern erstellt, so ist es wichtig jedem stets
die aktuellste Version der Dateien bereithalten zu können. Des Weiteren ist es
wichtig Änderungen zu dokumentieren und gegebenenfalls das Projekt auf einen
älteren Stand zurücksetzen zu können. Hier kommt das Versionskontrollprogramm
Subversion (SVN) ins Spiel. Es dokumentiert selbständig Änderungen an Dateien.
Dazu legt es bei jedem Speichervorgang, dem sogenannten Einchecken, eine neue
Revisionsnummer an, mit deren Hilfe stets ersichtlich ist wann, was genau und wo
etwas geändert wurde. Zusätzlich bietet dies den Vorteil, dass der Entwickler bei
aktualisieren seiner Dateien nicht mehr alle neu kopieren, sondern nur noch die
seit seinem letzten Aktualisierungvorgang geänderten Dateien neu aus dem
Repository zu beziehen braucht. Die SVN Unterstützung in Zend Studio wird
beispielsweise über die Plugins Subclipse und Subversive bereitgestellt. Die
nachfolgenden Ausführungen werden anhand von Subclipse erläutert, wobei sich
dieses jedoch von Subversive nur marginal unterscheidet.
22
3.8 Integration von Subclipse in Zend Studio
Nach der Installation über den Updatemanager von Zend Studio integriert sich das
Programm selbständig in die Explorer Perspektive. Die Symbole der einzelnen
Dateien und Ordner werden mit kleinen Zeichen versehen, die den aktuellen Status
anzeigen. Des Weiteren ist im Kontektmenü der Eintrag Team mit allen
Funktionalitäten des SVN - Clients versehen. Die Team Synchronisation - View
bietet eine Übersicht zu den lokal und im Repository geänderten Dateien. Des
Weiteren kann jetzt auch die SVN Exploring – View verwendet werden.
3.9 Repository aktivieren und auschecken
Die SVN Exploring - Perspective bietet Zugriff auf ein gesamtes Repository. Der hier
enthaltene Eintrag zum Repository wird benötigt, damit die SVN Funktionen in
einem Projekt genutzt werden können. Hier wird für Zend Studio definiert, mit
welchen Dateien sich das Projekt synchronisieren muss, also welche lokalen
Dateien ein Abbild des Repositorys darstellen sollen. Nach einen Klick auf Add SVN
Repository (zu finden in der oberen rechten Hälfte der SVN Repositories - View),
der Eingabe der Repository URL und evtl. der Eingabe eines Nutzernamens und
Passworts ist das Repository sichtbar, bzw. dessen Zugriff aktiviert. Nun wählt man
den gewünschten Ordner, welcher sich i.d.R trunk nennt, und wählt nach Klick auf
den gewünschten Ordner im Kontextmenu auf Checkout. Nach Auswahl, ob diese
Dateien als ein gesamtes Projekt ausgecheckt oder sich in ein vorhandenes
integrieren sollen, ist der Vorgang des erstmaligen Dateibezugs beendet. Fortan
kann man über die bereits erwähnte Team Synchronisation - Perspective und dem
Kontextmenü die Repository Dateien aktualisiert werden.
23
3.10 Prozedur des SVN Merge-, Update-, und Eincheckvorgangs
Diese drei Tätigkeiten werden idealerweise in der Team Synchronisation -
Perspective getätigt. Der Vollständigkeit halber sei hier erwähnt, dass diese
Funktionen auch im Kontextmenu des PHP Explorers aufgerufen werden können.
Dies ist jedoch aufgrund der mangelnden Übersicht, vor allem über Dateikonflikte,
nicht zu empfehlen. Durch einem Klick auf Synchronize SVN in der Synchronize –
View ist die Liste aktualisiert. Nun kann nach lokalen Dateiänderungen, Änderungen
im Repository und nach Merge Konflikten gefiltert werden. Über das Kontextmenü
können jetzt einzelne Dateien verglichen oder Änderungen auf beiden Seiten
synchronisiert werden.
Bevor jedoch Änderungen in das lokale Verzeichnis oder das des SVN überschrieben
werden sollte zuerst nach Merge-Konflikten geschaut werden. Dies sind
Dateiänderungen, welche beim synchronisieren Probleme hervorrufen werden.
Nimmt man Änderungen an Textdateien vor, so können diese auf der anderen Seite
(lokal oder Repository), sofern sie nicht die selbe Zeile betreffen, ohne Probleme
synchronisiert werden. Bei binären Dateien (z.B. Bildern) oder Änderungen an einer
gleichen Textzeile, muss der Nutzer entscheiden, welche der Änderungen die
richtige oder aktuellste ist. Dazu wählt man im Kontextmenü Edit Conflicts aus. Es
öffnet sich ein Editorfenster zum Vergleich der lokalen Datei mit der aktuellen
Repository Version. Auf der linken Seite ist die lokale und auf der rechten die des
Repository zu sehen. Die nachfolgende Abbildung zeigt solch ein Vergleichsfenster.
In ihm sind sämtliche Differenzen ersichtlich und können sofort mittels Klick auf die
Verbindungsstellen behoben werden oder müssen bei Konflikten vom Entwickler
von Hand nachbearbeitet werden.
24
Abbildung 8 Team-Synchronisation mit SVN-Dateivergleich
Die mit rot markierten Streifen zwischen den Editoren signalisieren Konfliktzeilen.
Nachdem man sich diese angesehen und/oder editiert hat, wählt man im
Kontektmenü Override and Update oder Override and Commit. Der erste Punkt
dient dazu SVN mitzuteilen, dass nicht bearbeitete Konflikte vom SVN in die lokale
Datei zu überspielen sind. Der zweite Punkt überspielt die aktuelle Datei ins SVN
ohne auf weitere Konflikte zu achten. Alternativ können auch die editierten
Änderungen vorerst nur lokal beibehalten werden. Dazu wählt man den Punkt Mark
As Merged um die Änderungen dem SVN einem späteren Zeitpunkt zu übermitteln.
Treten keine Konflikte mehr auf und man möchte sämtliche Dateiänderungen aus
dem Repository beziehen, so tätigt man dies mit einem Klick auf Update All
25
Incoming Changes in der Synchronize - View. Damit werden sämtliche Repository
Änderungen in die lokalen Dateien einfügen.
Wurden Änderungen an den Dateien auf lokaler Seite vorgenommen, so wird mit
einem Klick im Synchronize View unter Commit All Outgoing Changes... ein Dialog
geöffnet. In diesem nachfolgenden Fenster wird mit der Auswahl eines Commit
Kommentars und der Markierung der zu übertragenen Dateien der Commit initiiert.
Dies bedeutet, dass die Ordner und Dateien in das Repository eingepflegt und die
Revisionsnummer erhöht wird.
3.11 Zend Debugger
Früher oder später werden in einer Entwicklung Fehler entstehen. Das Debugging
mittels Software stellt eines der wichtigsten Funktionalitäten beim Testen von
Software dar. Es ermöglicht den Script (oder auch das Programm) dynamisch, d.h.
beim Ausführen, an gewünschter Stelle zu pausieren und sich den aktuellen
Zustand des ausgeben und evtl. sogar ändern zu lassen. Somit können Fehler bei
richtiger Anwendung (sogenannte Bugs) schneller und einfacher als bspw. mit
Testausgaben von einzelnen Variablen im Browser gefunden und behoben werden.3
Der Zend Debugger ist ein sogenannter Remotedebugger. Er ermöglicht es den
Debugprozess auf einem externen Server auszuführen und die Dateien für
Debugprozesse zu nutzen. Mit den nächsten Kapiteln sollen die vorbereitenden
Tätigkeiten und die mögliche Nutzung des Debuggers gezeigt werden.
3 [Pri06], S. 21
26
3.12 Installation und Konfiguration des Debuggers
Zur Installation des Debuggers benötigt man zwei Dateien. Zum Einen muss man im
Root Verzeichnis des auszuführenden Servers eine Datei namens dummy.php
speichern und zum Zweiten wird eine Bibliotheksfunktion zum Ausführen des
Programms benötigt. Deren Standort variiert je nach verwendetem Betriebssystem.
Sind beide in den entsprechenden Verzeichnissen hinterlegt muss man dem Server
in der php.ini nur noch die Erlaubnisse eines Remotezugriffs mitteilen.4 Nun kann
der Debugger im Zend Studio genutzt werden. Genauere Anleitung zur Installation
kann in Anlage E: Installing the Zend Debugger eingesehen werden.
Des Weiteren ist ein Plugin für den Browser Firefox von Nutzen. Die sogenannte
Zend Studio Toolbar integriert sich nach Installation reibungslos in den Browser und
bietet vereinfachten Zugriff auf Debugprozesse von Zend Studio. Die URL der
Installationsdatei kann in Anlage A: Plugin Downloadlinks eingesehen werden.
Nachfolgend zeigt eine Abbildung den Ausschnitt des Browserfensters, in welchem
die Toolbar integriert wird. Relevante Nutzungseinstellungen des Plugins sind keine
zu treffen, da benötigte Änderungen einzig auf Serverseite mittels dummy.php und
php.ini getroffen werden müssen.5
Abbildung 9 Firefox mit Zend Toolbar
4 [Zen07], S. 1 f. 5 [Zen09], S. 3 ff.
27
3.13 Verwendung des Debuggers
Der Zend Debugger beherrscht im Wesentlichen das Profiling, das ausgeben eines
Stack Traces und letztendlich natürlich das Debuggen selbst. Im Folgenden werden
diese separat behandelt, da sie eigenständige Funktionalitäten darstellen.
Kommt ein Script beim Aufruf auf lange Ausführungszeiten, so ist es wichtig den
Bereich der Zeiteinbußen einzugrenzen. Der Profiler dient hier als entscheidende
Hilfe. Er wird mittels Browser-Toolbar oder im Zend Studio selbst auf eine
Serveranfrage (oder auch Serverrequest), d.h. das Ausführen eines Scriptes,
angewandt. Nachdem der Request beendet ist, zeigt er verschiedene Eigenschaften
in einer Statistik an. Die nachfolgende Abblidung zeigt solch eine Statistik.
Enthalten sind die Anzahl der Aufrufe einer Klasse bzw. Methode, die Gesamtzeit,
mit welcher der Server in diesem Teil der Datei mit der Abarbeit beschäftigt war
und Aufrufanzahl.
28
Abbildung 10 ZendDebugger – Profiler
Die namensgebende Funktion ist das Debuggen. Mit ihr kann man die Ausführung
des Skriptes an beliebiger Stelle pausieren und sich die aktuellen
Variablenbelegungen anzeigen lassen. Um dem Skript mitzuteilen, wo er halten
soll, müssen sogenannte Breakpoints gesetzt sein. Sie sind Haltepunkte, mit denen
man dem Server mitteilt, dass, sollte die Skriptausführung an diese Stelle gelangen,
auf weitere Eingaben gewartet werden soll. Angelegt werden sie, indem man in der
Editor – View links auf die Zeilenanzahl doppelt klickt. Nun kann abermals mittels
Browser-Toolbar oder im Zend Studio selbst der Debugprozess gestartet werden.
Das Firefox-Plugin bietet hierbei die Möglichkeit den Debugger definierter
einzusetzen, indem beispielsweise die aktuelle Seite einmalig neu geladen wird
oder der nächste aktivierte Link den Debugger startet. Nun, nachdem pausiert
wurde, können sämtliche deklarierte Variablen und deren Inhalt, wie in der
nachfolgenden Abbildung dargestellt, eingesehen und auch verändert werden,
sodass der Skript im nächsten Schritt mit den editierten Werten weiter rechnet.
29
Zur Steuerung des weiteren Debugprozesses nach erfolgreichem pausieren des
Skriptes kann man jetzt die Skriptausführung in Einzelschritten innerhalb der
aktuellen Methode weiterverfolgen, in einen aktuellen Methodenaufruf hinein
springen (im Bild zu sehen) oder aus dieser Methode herausgehen und in den
übergeordneten Aufruf wechseln. Die letzte Möglichkeit besteht darin, dem
Debugger mitzuteilen, dass er den Skript, bis zum evtl. nächsten Breakpoint,
normal ausführen soll. Die dafür verwendeten Shortcuts können der Tabelle der
Anlage B: Wichtige Shortcuts in Zend Studio entnommen werden.
Abbildung 11 Debug Perspective
Die letzte wichtige Funktion ist der Stack Trace. Je verschachtelter eine
Requestabarbeitung, d.h. desto mehr Methoden aufgerufen werden, je
undurchsichtiger ist der gesamte Request durchzusehen. Wenn sich nun an einer
Stelle ein Fehler bemerkbar macht, so wurde er meist viel früher erstellt und
30
weitergereicht, bis er sich später bemerkbar macht. Der Stack Trace dient nun
dazu an einem gewünschten Punkt die Aufrufhistorie von der jetzigen Methode bis
vom Ausgangspunkt, d.h. der ersten aufgerufenen Methode, zurückverfolgen zu
können. Da er sehr eng mit den Breakpoints vernetzt ist, wurde er auch in die
Debug - Perspective eingesetzt und ist bei jedem Debugstopp, wie im vorherigen
Bild dargestellt, sichtbar. Des Weiteren sind die einzelnen Einträge im Trace
verlinkt, wodurch man mittels Klick auf einen Eintrag zu diesem Punkt in der
Abarbeitung „zurückspringen“ kann.
3.14 Abschließende Worte zu Erweiterungen
In den vorhergehenden Kapiteln wurde eine mögliche Verwendung des Zend Studio
mit verschiedenen integrierten Funktionen und zusätzlich installierten Plugins
gezeigt. Jedoch stellen diese nur einen geringen Teil der Bandbreite an
Erweiterungen dar. Durch die einfache, wie bereits am Beispiel von Subclipse und
AmaterasUML gezeigte, Erweiterbarkeit existieren bereits eine Menge solcher
nützlichen Erweiterungen.
31
4 Fazit
Durch den einheitlichen Zugang zu vielen Funktionalitäten stellen
Entwicklungsumgebungen einen wesentlichen Aspekt einer effektiven
softwareunterstützten Entwicklungsarbeit dar. In einem wachsendem Projekt mit
hohem Verbrauch an Zeit, einer steigenden Menge an Dateien oder einer Arbeit,
die es ermöglichen soll im Team zu entwickeln, spielt eine IDE ihre Stärken in
steigendem Maße aus. Zend Studio stellt hier eine wichtige Rolle in der Entwicklung
von PHP Projekten dar, da die IDE nach Bedarf an die Wünsche des Entwicklers
funktional als auch optisch angepasst werden kann. In der Grundausstattung besitzt
es bereits eine Menge an Funktionalitäten, welche durch einen einfachen
Installationsprozess erweitert werden können. Dies, und die Tatsache, dass Zend
Studio direkt für PHP entwickelt wurde, macht es zu einer starken Unterstützung in
der Webprogrammierung. Zum Zeitpunkt der Verfassung dieser Arbeit war die
aktuelle Version 7.2. Es wurde aber bereits eine neue Version 8.0 angekündigt. In
ihr sollen dann Funktionen wie ein erweiterter JavaScript Support von Bibliotheken
(JQuery, Prototype, etc.) oder VMWare Unterstützung zur verbesserten Entwicklung
in virtualisierten Systemen integriert sein.6 Die weitere Entwicklung von Zend
Studio wird zeigen, ob es seine Wichtigkeit auch später behalten wird.
6 [Zen10a], S. 1
32
Anlagenverzeichnis
Anlage A: Plugin Downloadlinks (Blatt 1)
Anlage B: Wichtige Shortcuts in Zend Studio (Blatt 2)
Anlage C: Wichtige PHPDocumentor Tags
Anlage D: Zend Studio 7.2 User Guide (externe PDF)
Anlage E: Installing the Zend Debugger (externe PDF)
Anlage F: Installing the Zend Browser Toolbar (externe PDF)
Anlage G: Übersicht der einzelnen PHP IDEs (externes Excel-Sheet)
33
Anlage A: Plugin Downloadlinks
Die nun folgenden Links repräsentieren die Download URLs zu den einzelnen, in der
Arbeit vorgestellten, Plugins. Diese müssen, wie bereits im Kapitel
Funktionserweiterung mithilfe des Plugin Systems erläutert, in Zend Studio
eingegeben oder über das Dateisystem integriert werden.
AmaterasUML
http://sourceforge.jp/frs/redir.php?m=iij&f=%2Famateras%2F38882%2FAmaterasU
ML_1.3.2.zip
ArgoEclipse
http://argoeclipse.tigris.org/update_site
PHP CodeSniffer
http://www.phpsrc.org/eclipse/pti/
Subclipse
http://subclipse.tigris.org/update_1.6.x
Zend Studio Toolbar for Firefox
http://downloads.zend.com/studio_plugins/2.3/ZendFirefoxToolbar-2.3.xpi
34
Anlage B: Wichtige Shortcuts
Tastenkombination Aktion Anwendunsort
Strg + B Projekt bauen (Build).
D.h. alle Symbole, wie
Klassen, Vererbungen,
etc., aktualisieren.
PHP - Perspective
F5 In Methodenaufruf
hineinspringen (Step
Into).
Debug – Perspective
F6 In gleicher Ebene
weitergehen (Step Over).
Debug – Perspective
F7 Aus Methode
herausspringen (Step
Return).
Debug – Perspective
F8 Normale Ausführung bis
zum nächsten Breakpoint
fortsetzen (Resume).
Debug – Perspective
Strg + Leertaste Content Assist öffnen Editor - View
Strg + O Outliner öffnen. Zeigt
alle Methoden und
Variablen der aktuellen
Klasse an.
Editor – View
Strg + T Type Hierarchy öffnen.
Zeigt alle erbenden
Klassen der aktuell
markierten an.
Editor – View
Strg + [Bild Auf|Bild Ab] Wechsel zwischen den
einzelnen Editortabs.
Editor – View
Strg + W Aktuelles Editorfenster
schließen.
Editor - View
35
Strg + D Aktuelle Zeile löschen. Editor - View
Strg + F Suche in aktueller Datei
(Find/Replace).
Editor – View
Strg + H Dateisuche öffnen
(Search). Eingrenzung für
gewünschte Dateien
möglich.
PHP Explorer – View
36
Anlage C: Wichtige PHPDocumentor Tags
Tag Kurzbeschreibung
@author Der Author des Dokuments oder
Dokumentenabschnitts (Methode, etc.).
@copyright Definiert das Copyright einer Datei.
@deprecated Zeigt an, dass diese Klasse / Methode in Zukunft
nicht mehr verwendet werden sollte.
@licence Lizentzyp der Datei.
@param Definiert einen übergebenen Parameter. Die
verwendete Syntax könnte lauten:
@param [Typ] $name - Kurzbeschreibung
@return Gibt den Typ des Returnwertes an (z.B. string,
array, stdClass).
@see Gibt einen Hinweis auf externe, zu betrachtende
Methoden / Klassen.
@throws Gibt die in der Methode geworfenen
Exceptionklassen an.
@uses Zeigt Verwendungen von externen Variablen /
Klassen an.
37
Literaturverzeichnis
[Eng98] Engels, G., Schäfer, W.:“Programmentwicklungsumgebungen -
Konzepte und Realisierung“, 1. Auflage, Stuttgart, Teubner, 1998
[Mar09] Martin, R.: „Clean Code – Refactoring, Patterns, Testen und Techniken
für sauberen Code“, 1. Auflage, Heidelberg et. al., mitp-Verlag, 2009
[Mör09] Möhrke, C.: „Besser PHP Programmieren - Handbuch professioneller
PHP-Techniken“, 3. Auflage, Bonn, Galileo Press, 2009
[Pri06] Priebsch, S.: „Enterprise PHP Tools - Werkzeuge und Methoden für
einen effizienten Entwicklungsprozess“, Frankfurt am Main,
entwickler.press, 2006
[Dot10] dotSource GmbH: „dotSource Magento Wiki“, 2010,
http://wiki.dotsource.de/bin/view/Magento/PHP_Development_Guides
Abruf: 18.09.2010
[Goo09] Google Spreadsheets: “PHP IDE 31. Jan 2009”, 2009,
http://spreadsheets.google.com/ccc?key=pV8XyUSUOM7GsmVMLVit0Hw
Abruf: 18.09.2010
[Zen09] Zend Technologies: “Installation and User Guide – Zend Browser
Toolbar”, 2009, http://static.zend.com/topics/Zend-Debugger-
Toolbar-Installation-Guide.pdf Abruf: 25.09.201
[Zen07] Zend Technologies: „Installing the Zend Debugger“, 2007,
http://static.zend.com/topics/Debugger-Install.pdf Abruf: 25.09.2010
[Zen10a] Zend Technologies: “Zend Studio 8 – Release Notes“, 2010,
http://www.zend.com/topics/Zend-Studio-8.0.0-b2-Release-Notes.txt
Abruf: 25.09.2010
[Zen10b] Zend Technologies: „User Guide – Zend Studio 7.x“, 2010,
http://www.zend.com/topics/Zend-Studio-7-User-Guide-v7-2.pdf
Abruf: 25.09.2010
38
Glossar
C
Content Assist
Dynamisches Anzeigen von Befehlsvervollständigungen, abhängig vom
eingegebenen Präfix.
K
Kontextmenü
Optionsansicht, welche meist über einen Rechtsklick auf einem Objekt
ausgeführt wird. Die dabei angezeigten Daten sind auswahl-/
objektabhängig.
P
Perspective (Zend Studio)
Sie definiert einen Grundaufbau des Programmlayouts. Es existieren mehrere
Views, welche meist einer Grundfunktion angepasst sind (z.B. PHP, Debug,
SVN). Ihr Inhalt besteht aus verschiedenen Views.
PHP
Scriptsprache, welche meißt bei der Entwicklung von Webapplikationen
verwendet wird.
Plugin
Erweiterung zu einem bestehenden Programm in Form einer Software.
39
Profiling
Dient der Anzeige relevanter Daten an Zeit- und Speicherverwendungen
eines Programmablaufs.
Project (Zend Studio)
Strukturelle Trennung von Softwareentwicklungen innerhalb eines
Workspace.
R
Remotedebugger
Debugger, welcher einen Debugzugriff auf Dateien von entfernten Systemen
ermöglicht (Sogenanntes Client–Server-Modell). Dabei ist zu beachten, dass
die Sicherheitsvorkehrungen des Servers den Zugriff über die verwendeten
Ports und IPs erlauben.
Repository
Ist der Datenpool, in dem beim SVN sämtliche Änderungen nach
Versionsnummer, Commitautor und –kommentar gespeichert sind.
S
Social Commerce
Art des Onlinevertriebs, bei der die Einbeziehung des Kunden in den Kauf
und weitere damit verbundene Aktiviäten gefördert wird. Im Vordergrund
steht die Kundenbindung aufgrund des sozialen Mehrwertes eines solchen
Onlinevertriebs.
SVN
40
Versionskontrollprogramm, welches häufig in Softwareprojekten verwendet
wird, da sämtliche Versionszyklen einseh- und wiederverwendbar sind.
Syntax Coloring
Farbliche Hervorhebung von sprachenspezifischen Befehlen (z.B. Schleifen
oder Verzweigungen).
V
View (Zend Studio)
Eine View ist ein Teil einer Perspektive, in welcher eine Funktion abgebildet
wird (z.B. Editoransicht, Debug Output).
W
Workspace (Zend Studio)
Stellt eine strukturelle Trennung von Projekten, in Form eines
auszuwählenden Ordners, dar. Innerhalb eines Workspace können mehrere
Projekte gleichzeitig bearbeitet werden.
Ehrenwörtliche Erklärung
Ich erkläre hiermit ehrenwörtlich,
1. dass ich meine Studienarbeit mit dem Thema:
Effizientere PHP Entwicklung mit Zend Studio - Richtiger Umgang mit wichtigen
Funktionen
ohne fremde Hilfe angefertigt habe,
2. dass ich die Übernahme wörtlicher Zitate aus der Literatur sowie die
Verwendung der Gedanken anderer Autoren an den entsprechenden Stellen
innerhalb der Arbeit gekennzeichnet habe und
3. dass ich meine Studienarbeit bei keiner anderen Prüfung vorgelegt habe.
Ich bin mir bewusst, dass eine falsche Erklärung rechtliche Folgen haben wird.
Ort, Datum
Unterschrift
