Multitierarchitectuur

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

Multitierarchitectuur betekent dat de structuur van software (de architectuur) opgebouwd is uit meerdere lagen. Vaak wordt ook wel gesproken van de n-tierarchitectuur. Een bekende uitvoering van een multitierarchitectuur is het client-servermodel, waarbij sprake is van een 2-tierarchitectuur.

De gedachte achter tiers[bewerken]

De gedachte achter een multitierarchitectuur begint bij de gedachte om software op te delen in meerdere componenten die met elkaar samenwerken. Het idee achter componenten is weer om ontkoppeling van functionaliteit en hergebruik van functionaliteit te stimuleren. Iedere component heeft nu zijn eigen verantwoordelijkheden. Een veelvoorkomende architectuur is een 3-tierarchitectuur. In een dergelijke architectuur is er een afzonderlijke tier voor de presentatie, de business logic + datatoegang en dataopslag.

Tier vs. laag[bewerken]

De termen tier en laag worden vaak door elkaar gebruikt. Een belangrijk onderscheid dat gemaakt kan worden tussen een tier en een laag is dat iedere tier feitelijk op een apart systeem kan draaien, als een afzonderlijk proces. In het voorbeeld van de 3-tierarchitectuur van hierboven, zal de presentatielaag (bijvoorbeeld een Windows-venster) op een client draaien, terwijl de businesslogica en de datatoegang als middelste tier op een server draaien. Tenslotte zal de datatier weer op een aparte databaseserver draaien.

Lagen die men aanbrengt in softwaretoepassingen zijn vooral logische opdelingen in de software zelf. Ondanks dat iedere laag afzonderlijk in een pakket of bibliotheek gecompileerd zou kunnen worden, zullen de lagen (vaak) als één proces op dezelfde client draaien.

Steeds weer een tier erbij[bewerken]

In het begin van het computertijdperk werd software op zogenaamde ponskaarten gedrukt. De ponskaart bevatte zowel de gegevens als de rekenkundige bewerkingen. Deze werden aan de computer gevoerd en deze spuugde een resultaat (waarschijnlijk ook op een ponskaart) uit. Het rekenprogramma en de gegevens waren verwerkt in één tier: de ponskaart.

In de loop van de ontwikkeling werden computers steeds intelligenter en konden ze steeds meer. Een van de ontwikkelingen was netwerktechnologie en gegevensopslag. Er ontstond met deze ontwikkeling ook een behoefte om de verantwoordelijkheden van de gegevensopslag en het verwerken van gegevens in de software te scheiden: het ontstaan van een 2-tierarchitectuur, het client-servermodel.

Met de komst van het internet, de uitgave van verschillende webbrowsers en webapplicaties kwam er behoefte om nog een laag te onderscheiden. Op deze manier zouden er drie tiers ontstaan: een tier voor de presentatie en weergave, een tier voor de applicatie- en businesslogica en een tier voor de gegevensopslag.

Een multitierarchitectuur kan men verkrijgen door het tieridee heel ver door te voeren. Men zou in de presentatietier ook kunnen spreken van een presentatiegedeelte en een applicatiegedeelte. Voorbeeld: in webformulieren is er een laag presentatie (HTML-opmaak) en er is een applicatielaag (code-behind, die de invoer controleert na de verzend-actie).

Toepasbaarheid en efficiëntie[bewerken]

Een belangrijk doel van het opdelen van software in tiers was om het mogelijk te maken software op te delen in brokken met duidelijk omschreven functionaliteit. Het zou dan mogelijk zijn om deze componenten of tiers te hergebruiken voor andere doeleinden. Denk aan een applicatietier die gegevens vanuit zowel Web-interface als Windows-controleert. Een dergelijke tier hoeft maar één keer geschreven te worden. Tevens zou het de ontwikkeling van software in onafhankelijke teams ook beter mogelijk maken, omdat de verantwoordelijkheden van de onderdelen duidelijk omschreven zijn.

De tierarchitectuur kan men heel ver doorvoeren. Zover zelfs, dat er tiers ontstaan die eigenlijk alleen maar gegevens doorgeven aan volgende tiers. Men kan zich dan afvragen of men dan niet te ver is gegaan in het structeren van software in meerdere tiers. Het resultaat is een veel te omvangrijke applicatie, met veel nutteloze functies en modules, plus een grote kans dat de gebruikerseisen onvoldoende zijn uitgewerkt.

Zie ook[bewerken]