Symfony

Symfony wurde 2005 entwickelt und wird aktuell vom französischen Softwareentwickler SensioLabs gesponsert und unterstützt. Das Framework basiert auf der Programmiersprache PHP und wurde als Gegenpart zum kurz vorher entstandenen Framework Ruby on Rails entwickelt. Nachdem „Rails“, geschrieben in der Programmiersprache Ruby, in kurzer Zeit große Popularität erreichte, vergrößerte sich die Notwendigkeit eines entsprechenden PHP-Frameworks.

Was ist ein Framework?

Um die Besonderheiten Symfonys erklären zu können, ist es notwendig, den Begriff Framework zu erläutern. Ein Webframework ist eine Softwaresammlung zur Programmierung von WEBSITES, Anwendungen oder Services. Ähnlich eines Werkzeugkastens besteht die Sammlung aus verschiedenen Werkzeugen, Best Practices, Konzepten, vordefinierten Klassen und „Bauanleitungen“. Dadurch können Applikationen wie z.B. Formulare, Widgets oder Konfiguratoren sehr schnell so programmiert werden, dass das Script clientseitig, also im Browser abgerufen wird. Der Entwickler spart sich durch die Vielzahl der bereits entwickelten Lösungen Zeit, die Website-Performance wird durch die clientseitige Verarbeitung wesentlich verbessert.

Symfony als Webframework

Symfony wird in der Programmiersprache PHP geschrieben. Es besteht selbst aus zahlreichen voneinander unabhängigen Modulen, so genannten Bundles und bietet als Plattform die Möglichkeit, eigene Pakete zu entwickeln. Jedes Bundle kann vom verantwortlichen Programmierer freigegeben und von anderen Entwicklern übernommen werden. Dadurch verringert sich der Programmieraufwand erheblich, dajeder Entwickler bereits bestehende Lösungen importieren und individualisieren kann, statt die ganze Applikation von Grund auf zu programmieren. Symfony verfügt über zahlreiche technische Besonderheiten wie Datenbankzugriff, Twig-Templates, Mehrsprachigkeit, Datenvalidierung, Caching uvm., die die Arbeit zusätzlich beschleunigen. Die Bundles können durch die Verwendung verschiedener Entwurfsmuster wie Observer, Strategy-Pattern, Dependeny Incjection, MVC (Model View Controller) uvm. jederzeit verändert, angepasst oder eben auch wiederverwendet werden.

Model – View – Controller

MVC ist ein Entwurfs- bzw. Architekturmuster, das sowohl Anpassbarkeit als auch Wiederverwertung einer Software ermöglicht. Die Software wird dabei in drei Komponenten namens Model (das Datenmodell), View (die Präsentation) und Controller (die Programmsteuerung) unterteilt. Dadurch wird die Software flexibel nutzbar, weil einzelne Komponenten losgelöst von den anderen Komponenten bearbeitet werden können. Die einzelnen Komponenten werden wie folgt unterteilt:

• Model: Das Model verwaltet den Objektzustand und kommuniziert mit der Datenbank.
• View: Der View ist zuständig für die Darstellung der Daten, die aus der Model-Komponente kommen. Die Darstellung wird etwa als Button, Box etc. zuständig und spielt die Interaktionen mit diesen Elementen wieder zurück an das Model.
• Controller: Der Controller steht als Kommunikator zwischen Model und View.

Auf diese Weise können Anwendungen, die für die Ausspielung in verschiedenen Systemen vorgesehen sind, sehr einfach angepasst werden. Es reicht unter Umständen, lediglich View und Controller neu aufzusetzen, da die Daten aus dem Model immer gleichbleiben.

Symfony als Entwicklungsmethodik

Neben der Eigenschaft als Werkzeugkasten für die Entwicklung von Applikationen kann Symfony auch als eigene Entwicklungsmethodik angesehen werden. Diese Methodik beruht auf relativ starren Vorgaben, die aber sehr prozessorientiert sind. Die Verfügbarkeit zahlreicher Best Practice Beispiele macht es Entwicklern möglich, sehr schnell Lösungen für sehr komplexe Aufgaben zu finden. Symfony fokussiert sich dabei auf die SOLID-Prinzipien.

SOLID-Prinzipien

SOLID bezeichnet fünf Prinzipien zur Vereinfachung und Verdeutlichung der Softwareprogrammierung. Durch Verwendung dieser Prinzipien soll die Programmierung flexibler, adabtierbar und klarer wirken. Die einzelnen Prinzipien lassen sich folgendermaßen aufbrechen:

• Single-responsibility principle: Eine Klasse darf nur eine Verantwortlichkeit besitzen und sollte nur von einer Spezifikation geändert werden können.
• Open-closed principle: Einheiten sollten Erweiterungen zulassen, aber Modifikationen verweigern.
• Liskov substitution principle: Programmobjekte sollten ohne Probleme durch Instanzen ihrer Untertypen austauschbar sein.
• Interface segregation principle: Eine Lösung mit mehreren client-spezifischen Oberflächen ist einer einzigen Oberfläche mit allen Lösungen vorzuziehen.
• Dependency inversion principle: Module höherer Ebenen sollten nicht von niedrigeren Ebenen abhängen.

Die starren Vorgaben und die Beachtung der Prinzipien sorgen für eine klar definierte, erfolgsorientierte Programmierlogik.

Symfony – Philosophie

Neben den zahlreichen Eigenschaften eines leistungsfähigen Webframeworks verfügt Symfony darüber hinaus über eine engagierte und große Community aus. Diese zeichnet sich durch eine eigene, schriftlich fixierte Philosophie aus. In einem eigenen „Code of Conduct“ wurde die Vision ebenso festgelegt wie Standards sowie Verantwortungen, die jeder mit Symfony arbeitende Entwickler verinnerlichen sollte. Das Resultat ist eine riesige Community voller Entwickler, die sich gegenseitig bei Problemen unterstützen oder mit Best Practice Entwicklungen helfen. Durch die gemeinsame Verbesserung werden auch die einzelnen Lösungen stets weiteroptimiert. Innerhalb der Community ist es möglich, sein Wissen durch zahlreiche Schulungen und Zertifikate zu vertiefen und für andere sichtbar zu machen – eine Möglichkeit, die wir bereits genutzt haben.

Fazit

Clientbasierte Webframeworks erleichtern die Einbindung von Singlepage Applications für den Entwickler ungemein und sorgen beim Nutzer für eine reibungslose Performance. Symfony ist aufgrund zahlreicher Vorteile eines der sinnvollsten Frameworks in der PHP-Sprache. Wir nutzen es z.B. für die Arbeit in SHOPWARE oder PIMCORE. Darüber hinaus wird Symfony von zahlreichen Projekten wie GOOGLE, FACEBOOK, Wikimedia, Magento oder Matomo erfolgreich eingesetzt – der beste Beweis für die Leistungsfähigkeit des Frameworks.