Creazione di un sistema di gestione magazzino / magazzino, con più posizioni per ciascun articolo

Sto creando un WMS con i seguenti requisiti di base:

1. Ogni elemento può trovarsi in più posizione s.
2. Una posizione può contenere più elementi .
3. Per ciascuna combinazione Località / elemento , devo essere in grado di tenere traccia di: QtyOnHand , QtyReserved e QtyAvailable .
4. Una posizione può contenere un'altra posizione .

Il comportamento di base richiesto per una posizione è:

1. Aggiunta / rimozione di un elemento con una quantità .
2. Aggiunta / rimozione di una posizione nidificata
3. Tracciamento delle quantità per ciascun elemento all'interno della posizione .

Sto tentando di scrivere il codice rimanendo fedele ai principi di progettazione OOP, ovvero:

1. Progettare interfacce di classe per riflettere comportamento anziché dati .
2. Evita Getter / setter s.
3. Dillo, non chiedere , il più possibile.

Con questo in mente, ecco il codice di base per una posizione:

public class Location{

    private final Map<InventoryItem, Integer> items = new HashMap<>();
    private final Set<Location> locations = new HashSet<>();

    public void add(InventoryItem item, int quantity) {
         if (items.containsKey(item)) {
             InventoryQuantity inventoryQuantity = items.get(item);
             items.put(item, inventoryQuantity.addQuantityOnHand(quantity));
         } else {
             items.put(item, quantity);
         }
    }

    public void add(Location location) {
        locations.add(location);
    }

    public void remove(InventoryItem item, int quantity) {
        if (items.keySet().contains(item)) {
            if ((items.get(item) - quantity) == 0) {
                items.remove(item);
            } else {
                items.put(item, items.get(item) - quantity);
            }
        }
    }

    public void remove(Location location) {
        locators.remove(location);
    }

}

Quindi ora che ho il comportamento di base per l'aggiunta / rimozione, sto avendo difficoltà a capire quale sarebbe il modo migliore per tenere traccia della quantità. Potrei creare una classe InventoryQuantity , come segue:

 public class InventoryQuantity {

    private InventoryItem item;

    private int quantityOnHand;

    private int quantityReserved;

    private int quantityAvailable;

    public InventoryItem getItem() {
        return item;
    }

    public void setItem(InventoryItem item) {
        this.item = item;
    }

    public int getQuantityOnHand() {
        return quantityOnHand;
    }

    public void setQuantityOnHand(int quantityOnHand) {
        this.quantityOnHand = quantityOnHand;
    }

    public int getQuantityReserved() {
        return quantityReserved;
    }

    public void setQuantityReserved(int quantityReserved) {
        this.quantityReserved = quantityReserved;
    }

    public int getQuantityAvailable() {
        return quantityAvailable;
    }

    public void setQuantityAvailable(int quantityAvailable) {
        this.quantityAvailable = quantityAvailable;
    }
}

e memorizza uno InventoryQuantity per ogni InventoryItem in Location , in questo modo:

private final Map<InventoryItem, InventoryQuantity> items = new HashMap<>();

Le mie domande / problemi sono le seguenti:

1. InventoryQuantity non sembra essere un oggetto reale con un definito comportamento ; piuttosto, sembra essere una struttura dati con l'unico scopo di memorizzare quantità dati (come evidenziato dall'esistenza di Getter / Setter); c'è un modo migliore?
2. Chiedi una posizione a getQuantityOnHandForItem (elemento) una violazione di Dillo, non chiedere ? D'altra parte, non sembra esserci un modo migliore per recuperare i dati ...

In realtà avevo altre domande, ma questo è quello che ricordo al momento. Se qualcuno può aiutarmi a capire / applicare efficacemente i principi, lo apprezzerei molto!