Component Diagram UML: le interfacce

Trovo che il Component Diagram sia il più utile dei diagrammi UML, poichè è chiaro,  facile da capire e sopratutto utile, dato che descrive come le varie parti di un'applicazione (component) interagiscono.

Può essere usato per descrivere l'interazione fra vari component, oppure fra le parti interne di un singolo component.

Vediamo un esempio di questo secondo tipo di uso.

Poniamo di avere un component (se si vuole concretizzare, una dll) che serve per la modellizzazione di un negozio.

Riporto qui un esempio preso dal sito di Rational - IBM (articolo completo) .

La figura rappresenta il component diagram della struttura interna e delle interfaccie verso l'esterno del componente "Store".

Nella simbologia UML 2.0, un' interfaccia esposta si disegna con un "lollipop" (un  "lecca-lecca")  cioè una linea dritta con un pallino in cima.

Invece, un'interfaccia richiesta si simboleggia con un "socket" cioè una linea con un mezzio cerchio in cima. 

Ovviamente lollipop e socket sono fatti per "agganciarsi" uno nell'altro.

(qui sopra Notazione UML 2.0)

(qui sopra Notazione UML 1)

Se pensiamo alla classe "Customer", possiamo dire che sicuramente avrà un'interfaccia "Person" attraverso la quale può esporre le sue proprietà interne. Un'interfaccia di questo tipo conterrà metodi come getName() oppure getPersonData()...

Possiamo dire quindi che "Customer" espone un'interfaccia verso l'esterno. Dunque dal rettangolo della classe Customer esce un lollipop chiamato "Person".

Discorso parallelo per "Product" che espone un'interfaccia (un lollipop) chiamata"OrderableItem". Questa interfaccia avrà metodi come getPrice() o getItemDescription()...

Guardiamo ora la classe "Order". Un ordine, per essere definito, deve avere il riferimento del prodotto acquistato e del cliente acquirente. Dunque, nella classe "Order"esisteranno dei metodi che richiedono come parametri delle istanze di  "Person" e "OrderableItem". Da "Order" escono quindi due socket, a simboleggiare le due interfaccia richieste.

    interface Person { }

    interface OrderableItem { }

    class Order

    { // Order richiede (ad esempio attraverso il costruttore) l'uso di due istanze delle interfacce Person e OrderableItem

       public Order(Person p, OrderableItem o) {       

        }

    }

    class Customer : Person {    }

    class Product : OrderableItem {    }

Collegando i socket con i lollipop si ottiene il collegamento fra le tre classi che costituiscono il componente. 

Ma il componente può avere interfaccie verso l'esterno.

Ad esempio l'interfaccia Account serve per collegare il Customer con i dati del conto di pagamento, gestiti da un altro componente. L'interfaccia account avrà metodi come: getAccountData(), ...

Un customer deve conoscere questi dati, dunque ha un'interfaccia rischiesta (socket) verso l'esterno del componente.

Il componente può esser parte di più programmi (un programma web di invio ordini da un sito internet, un programma di contabilità, un programma di data-mining....). In ogni caso dovrà esporre verso l'esterno un'interfaccia che riassuma i dati dell'ordine, chiamata "OrderEntry". Essa avrà metodi come: getTotalPrice(), getDateOfOrder(), ...

Dunque la classe "Order" espone vesro l'esterno del componente un lollipop chiamato "OrderEntry".