Alles over UML-pakketdiagrammen

Pakketdiagrammen zijn structurele diagrammen waarmee de organisatie en indeling van diverse modelelementen in de vorm van pakketten kan worden weergegeven. Een pakket is een groep gerelateerde UML-elementen zoals diagrammen, documenten, klassen of zelfs andere pakketten. Elk element zit ingebed in het pakket – weergegeven als een bestandsmap binnen het diagram – en wordt vervolgens hiërarchisch binnen dit diagram ingedeeld. Pakketdiagrammen worden meestal gebruikt als een visuele organisatie van de gelaagde architectuur binnen UML-classificeerders, zoals een softwaresysteem.

Voordelen van een pakketdiagram

Een goed ontworpen pakketdiagram biedt talloze voordelen voor wie een visualisatie van een UML-systeem of -project wil maken.

• Ze geven een duidelijk beeld van de hiërarchische structuur van diverse UML-elementen in een bepaald systeem. 
• Ze kunnen complexe klassediagrammen vereenvoudigen en in overzichtelijke beelden omzetten.
• Ze bieden waardevolle en hoogwaardige zichtbaarheid in grootschalige projecten en systemen.
• Ze kunnen gebruikt worden om een groot aantal verschillende projecten en systemen visueel te verduidelijken.
• Deze visuele weergaven kunnen vervolgens makkelijk worden bijgewerkt naarmate systemen en projecten zich verder ontwikkelen.

De opbouw van een pakketdiagram is relatief eenvoudig. Elk diagram bevat slechts twee symbolen:

Afbeelding symbool	Naam symbool	Beschrijving
	Pakket	Groepeert gemeenschappelijke elementen op basis van gegevens, gedrag of gebruikersinteractie
	Afhankelijkheid	Beschrijft de relatie tussen een bepaald element (pakket, benoemd element enz) en een ander

 

Deze symbolen kunnen op diverse manieren worden ingezet om verschillende iteraties van pakketten, afhankelijkheden en andere onderdelen binnen een systeem weer te geven. Dit zijn de basisonderdelen die u in een pakketdiagram tegenkomt:

• Pakket

  : een naamruimte waarin logisch gerelateerde onderdelen binnen een systeem worden samengebracht. Elk onderdeel binnen het pakket moet een verpakbaar element zijn en een unieke naam hebben.

• Verpakbaar element

  : een benoemd element, dat direct deel kan uitmaken van het pakket zelf. Dit kunnen gebeurtenissen, onderdelen, use-cases en pakketten zelf zijn. Verpakbare elementen kunnen ook worden weergegeven als een rechthoek binnen een pakket, aangeduid met de juiste naam.

• Afhankelijkheden

  : een visuele weergave van hoe één element (of reeks elementen) afhankelijk is van een ander element of zelf van invloed is op dit element. Afhankelijkheden worden opgedeeld in twee groepen: toegangs- en importafhankelijkheden. (Ga door naar de volgende sectie voor meer informatie.)

• Elementimport

  : een gerichte relatie tussen een importerende naamruimte en een geïmporteerd verpakbaar element. Dit wordt gebruikt om geselecteerde individuele elementen te importeren zonder daarvoor een pakket te hoeven importeren en dit openbaar te maken in een naamruimte.

• Pakketimport

  : een gerichte relatie tussen een importerende naamruimte en een geïmporteerd pakket. Met dit type gerichte relatie worden de namen van de leden van het geïmporteerde pakket aan de eigen naamruimte toegevoegd.

• Pakket samenvoegen

  : een gerichte relatie waarbij de inhoud van één pakket wordt uitgebreid met de inhoud van een ander pakket. Dit betekent in wezen dat de inhoud van de twee pakketten samen een geheel nieuw pakket vormen.

Pakketdiagrammen worden deels gebruikt om de import- en toegangsafhankelijkheden tussen pakketten, klassen, onderdelen en andere benoemde elementen binnen uw systeem te beschrijven. Elke afhankelijkheid wordt weergegeven in de vorm van een verbindingslijn met een pijl die het relatietype aangeeft tussen de twee of meer elementen. 

Er zijn twee belangrijke soorten afhankelijkheden:

Toegang

: geeft aan dat een pakket de hulp nodig heeft van de functies van een ander pakket.
Voorbeeld:

Import

: geeft aan dat functionaliteit vanuit één pakket geïmporteerd is naar een ander pakket.
Voorbeeld:

Afhankelijkheden kunnen ook verder worden onderverdeeld in de volgende categorieën:

• Gebruik

  : doet zich voor wanneer een bepaald benoemd element een ander element nodig heeft om volledig gedefinieerd en ingezet te worden. Voorbeeld: klant en leverancier.

• Abstractie

  : legt een verband tussen twee elementen die hetzelfde concept vertegenwoordigen maar dit op verschillende abstractieniveaus binnen het systeem weergeven (dit is meestal een relatie tussen klant en leverancier).

• Implementatie

  : beschrijft het plaatsen van een artefact binnen een implementatiedoel.

Zoals we al eerder in deze handleiding hebben gezien, zijn pakketten UML-constructies die gebruikt kunnen worden om de elementen binnen een UML-classificeerder in verschillende UML-diagrammen te organiseren. Pakketdiagrammen worden vaak gebruikt in:

• Use-casediagrammen

  : elke use-case wordt afgebeeld als een individueel pakket

• Klassediagrammen

  : klassen worden georganiseerd in pakketten

Pakketten kunnen ook worden gebruikt binnen andere UML-modeltypen om elementen zoals klassen, gegevensentiteiten en use-cases te organiseren en rangschikken. Door de pakketdiagramstructuur samen met andere UML-diagrammen te gebruiken, kunt u elk modeltype vereenvoudigen en daardoor overzichtelijker maken.

Modeldiagrammen

Pakketdiagrammen kunnen ook samen met modeldiagrammen worden gebruikt. Modeldiagrammen zijn een soort UML-hulpstructuurdiagram waarmee de logische, gedragsmatige of structurele aspecten van een systeem kunnen worden weergegeven. Zelfs simpele modellen kunnen moeilijk te begrijpen zijn als ze niet op een bepaalde manier visueel worden weergegeven. Het gebruik van pakketten biedt gebruikers een beter overzicht van een model, met duidelijke, ondubbelzinnige benoemde verwijzingen voor elk van de elementen die het bevat. Daarnaast kunnen duidelijk gelabelde afhankelijkheden de relaties tussen de verschillende elementen verduidelijken.

Bekijk de volgende sjabloon om te zien hoe een pakketdiagram de pakketten binnen een eenvoudige e-commerce webapp modelleert. Klik op de sjabloon om deze te bewerken en te ontdekken hoe u de structuur van een ontworpen systeem op pakketniveau kunt weergeven.