Vorrei disegnare uno schizzo UML per comunicare parte di un software, ma il tipo di relazione tra le classi non mi sembra molto chiaro.
Diciamo che voglio recuperare periodicamente gli ordini recenti dal database e aggiornare una vista grafica con i dettagli dell'ordine.
Questo è un esempio di pseudo codice molto semplificato ma la mia implementazione è java
//Order objects contain information about a single order
class Order
{
private String orderNumber;
private String buyerName;
public Order(String number, String name)
{
//initialize fields
}
//public getters
}
ora ho una classe chiamata Model che ha una singola funzione statica per il recupero degli ordini in un intervallo di tempo:
class Model
{
private Model()
{}
public static List<Order> getOrders(LocalDateTime from, LocalDateTime until)
{
//...get order objects from database and return
}
}
Model.getOrders() è accessibile dalla mia classe Controller che è responsabile del recupero di oggetti Order e dell'aggiornamento periodico di una vista
class Controller implements Runnable
{
private RecentOrdersView target; //view to update
private Controller()
{
}
public Controller getInstance(RecentOrdersView input)
{
//...singleton
//compose the returned object with the view, so it needs which view to update
}
public void Run()
{
//... client code runs this function periodically
List<Order> recentOrders = Model.getOrders(...);//get Orders
for(int i=0; i<recentOrders.size(); i++)
{
target.updateView(recentOrders.get(i).getOrderNumebr(),
recentOrders.get(i).getBuyerName());
}
}
}
Come potresti aver indovinato c'è una classe per la mia vista come segue:
class RecentOrdersView
{
private RecentOrdersView()
{
}
public RecentOrdersView getInstance()
{
//...singleton implementation
}
public void updateView(String orderNumber, String buyerName,...)
{
//...update the view based on the parameters
}
}
quindi il controllore e la vista sono implementati come singleton, ma il modello è accessibile tramite la funzione statica pubblica. Il codice cliente è responsabile di metterlo insieme:
class Client
{
public static void main(String[] args)
{
RecentOrderView view = RecentOrdersView.getInstance();
Runnable controller= Controller.getInstance(view);
//schedule controller to run periodically
}
}
Ora voglio creare un diagramma UML per questa configurazione, tuttavia non so se dovrei usare l'aggregazione o la composizione tra Controller , Model e Order
la mia ipotesi migliore è la seguente: 
Ho selezionato la relazione di composizione tra Client e RecentOrdersView e Controller , perché Client possiede un'istanza di ciascuno. Ho anche selezionato una relazione di aggregazione tra RecentOrdersView e Controller , perché Controller contiene un riferimento di RecentOrdersView (anche se non lo possiede).
dove sono confuso sono le relazioni tra Order , Controller e Model . Specifiche:
Relazione tra Model e Controller :
So che Controller chiama una funzione statica in Model , ma poiché non ci sono istanze di oggetti, non sono sicuro di cosa fare
Relazione tra Model e Order : Voglio quasi usare la composizione perché Model istanzia% Order oggetti, ma poiché ciò accade in una funzione statica non c'è un proprietario immediato, gli oggetti Order vengono passati torna a Controller
Relazione tra Controller e Order :
inside Controller method Run() è dove Order oggetti escono dall'ambito, ma Controller object non è quello che ha istanziato direttamente quegli oggetti. dovrei usare la composizione qui?
Grazie per aver letto questa lunga domanda. Apprezzo molto anche i consigli sul modello di progettazione generale utilizzato.