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 is om het mogelijk te maken software op te delen in brokken met duidelijk omschreven functionaliteit. Het is dan mogelijk zijn om deze componenten of tiers te hergebruiken voor andere doeleinden. Denk aan een applicatietier die gegevens vanuit zowel webinterface als Windows controleert. Een dergelijke tier hoeft maar één keer geschreven te worden. Tevens maakt het de ontwikkeling van software in onafhankelijke teams beter mogelijk, omdat de verantwoordelijkheden van de tiers duidelijk gescheiden zijn.

Zie ook[bewerken]