Het verschil: Drupal 7 vs Drupal 8

Dit artikel werd geschreven naar aanleiding van Drupalcon Amsterdam, eind 2015. Intussen zijn er heel wat stappen gezet in het Drupallandschap - zowel op technisch vlak als qua businessaanpak. Voor meer info, neem gerust contact op! Blijf zeker onze blog volgen voor meer informatie over Drupal 8-implementaties. 

Tijdens Drupalcon Amsterdam werd de beta release van Drupal 8 een feit. Het hoeft u niet te verwonderen dat dit een veelbesproken onderwerp was. In dit blogbericht geef ik een korte uiteenzetting over de fundamentele verschillen tussen Drupal 7 en Drupal 8, gevolgd door een voorbeeld van de implementatie in een custom module.

Spanning in de lucht

Begin oktober gingen we met een delegatie developers van Dropsolid de sfeer op Drupalcon Amsterdam opsnuiven. Met de beta release van Drupal 8 in aantocht hing er op zijn zachtst gezegd spanning in de lucht. Het was dan ook voor alle Dropsoldiers een leerrijke ervaring. Er werden ideeën en kaartjes uitgewisseld en er werden vriendschappen gesmeed. Daarenboven ging elk van ons met een rugzak vol kennis, gadgets en promomateriaal naar huis.

Een terugblik op de geschiedenis: PHP4 vs PHP5

Om te starten met de vergelijking tussen Drupal 7 en Drupal 8 keren we een klein decennium terug in de tijd. Rond 2005 maakten heel wat ontwikkelaars de overstap van PHP4 naar PHP5. PHP4 is voornamelijk proceduraal. Applicaties starten met een reeks aan superglobals, de code wordt uitgevoerd, variabelen keren terug en worden weergegeven. PHP5 is object-georiënteerd. Zo worden alle objecten by reference doorgegeven. Dit, en vele andere wijzigingen, zorgden voor een enorme vooruitgang qua performantie, caching en veiligheid.

En zo is de vergelijking tussen Drupal 7 en Drupal 8 snel gemaakt. Drupal 7 heeft deze PHP4-achtige procedurale benadering met superglobals. Opnieuw, code wordt uitgevoerd en variabelen worden geprint. Ondanks de implementatie van heel wat features uit PHP5 was Drupal 7 in essentie een PHP4-applicatie.

Met Drupal 8 betreden we echter onontgonnen terrein. De inlijving van het Symfony-framework betekent een enorme sprong voorwaarts. Symfony is één van de meest gebruikte frameworks in de PHP-gemeenschap en we kunnen ervanuit gaan dat het Drupal zowel robuuster als flexibeler zal maken. Begrijp me niet verkeerd, Drupal 7 is geweldig. De kernideeën van Drupal blijven bestaan. Je zal nog steeds nodes, views en blocks terugvinden. Alles wordt simpelweg toegankelijker, makkelijker te vatten en, om het met één woord te zeggen… beter. In lijn met het web

Dankzij Symfony kan Drupal ten volste gebruik maken van een object-georiënteerde aanpak. De architectuur van Drupal 8 zal meer lijken op de architectuur van het web; een request komt binnen, de server voert code uit en het resultaat (response) wordt teruggestuurd. Die requests en responses bestaan niet uit een lawine aan strings. Het zijn gestructureerde objecten met een gedefinieerd patroon. En dat is nu net hoe Symfony/HTTPKernel werkt. Bijgevolg krijgt Drupal een aantal functionaliteiten die in Drupal 7 niet out-of-the-box beschikbaar waren (bijvoorbeeld REST).

Hierdoor valt alles op zijn plaats. De Drupal 8-architectuur wordt logischer en toegankelijker voor ontwikkelaars met geen of beperkte ervaring met Drupal. Iedereen die het Symfony routing systeem kent, krijgt meer grip op Drupal 8 code.

Voorbeeld

Wat volgt is een voorbeeld van een Drupal 8 module om enkele van deze veranderingen aan te tonen. We beginnen met het creëren van onze module map onder modules/, om onze code in te plaatsen.

module/mymodule

Het eerste wat we nodig hebben is een infobestand, anders herkent Drupal onze module niet. Dit is een yaml bestand, net zoals in Symfony. Onze oude .info bestanden worden nu .info.yaml.

name: My Module
type: module
description: 'My cool Drupal 8 module.'
core: 8.x

 

Dit bestand moet als bestandsnaam dezelfde naam hebben als onze module en zich in de root van onze module bevinden.

modules/mymodule/mymodule.info.yaml

Vergeet de “type: module” niet in het bestand; anders zal Drupal het niet herkennen. In Drupal 8 is geen .module-bestand meer nodig alvorens modules opgepikt worden.

Een andere interessante eigenschap van .info.yaml is het “hidden” attribuut. Als deze op “true” staat dan kunnen we de module verbergen in de overzichtspagina.

Routing

Routing is eigenlijk waar we hook_menu voor gebruikten in Drupal 7. Eén van de belangrijkste functies was het creëren van paden en verbinden met callbacks. In Drupal 8 gebruiken we geen hook_menu’s meer. We maken gebruik van het Symfony routing system. We definiëren routes en schrijven callbacks in controllers (de “methods” van een Controller klasse).

Naast onze mymodule.info.yaml plaatsen we een mymodule.routing.yaml bestand. In dit bestand komt de definitie van een route.

mymodule.mymodule:
   path: '/hello-world'
   defaults:
      _content: '\Drupal\mymodule\Controller\MyModuleController::doSomething'
      _title: 'My Module'
   requirements:
      _permission: 'access content'

 

De eerste lijn definieert het begin van een nieuwe route voor module “mymodule”, het eerste deel is de naam van de route, het tweede deel de modulenaam. Op de tweede lijn definiëren we het pad.

Onder “defaults” hebben we een call die verwijst naar de method “doSomething” in de MyModuleController klasse (_content) en de default paginatitel. Ten slotte specifiëren we de permissies.

Vervolgens maken we de controller. In de “mymodule”-map creëren we een map “src”. Onze boomstructuur wordt dan:

mymodule/src/ mymodule/mymodule.info.yaml mymodule/mymodule.routing.yaml

In src/ maken we bestand MyModuleController.php, met daarin onze klasse:

<?php
/**
   * @file
      * Contains \Drupal\mymodule\Controller\MyModuleController.
   */
namespace Drupal\mymodule\Controller;
/**
   * MyModuleController.
   */
   class MyModuleController {
      /**
      * Generates an example page.
      */
      public function doSomething() {
         return array(
            '#markup' => t('Hello World!'),
         );
      }
   }

 

Zoals je kan zien is dit een zeer simpele implementatie, maar het demonstreert de essentie. Bovenaan definiëren we de namespace voor deze klasse. Vervolgens definiëren we onze klasse.

In MyModuleController is er een method die een renderbare array terugstuurt. Het enige dat we nu nog moeten doen is onze caches clearen en naar http://yoursite.com/hello-world gaan.

Onze mapstructuur is nu:

mymodule/src/MyModuleController.php
mymodule/mymodule.info.yaml
mymodule/mymodule.routing.yaml

Natuurlijk zijn er heel wat meer mogelijkheden, maar dat ligt buiten het bereik van dit artikel. Zij die zich willen verdiepen in Symfony kunnen terecht op http://symfony.com/doc/current/book/index.html.