Pattern per il salvataggio, l'aggiornamento e il recupero di oggetti in Java

Mentre progettavo applicazioni Java, mi sono imbattuto in uno schema comune in cui sto scrivendo un'applicazione che riceve ordini da un utente e li salva nello spazio di archiviazione. Quando un ordine è memorizzato, può anche essere recuperato tramite il suo ID e anche alcune azioni ad esso eseguite, ad es. ha il flag annullato impostato su true.

Il problema comune che ho è come gestire il comando, ad esempio cancella, richiesta. Diciamo che ho un OrderService, che ha un OrderRepository che gestisce l'archiviazione degli ordini (forse la repo si occupa di Hibernate ma non importa).

public OrderRepo {
    public void addOrder(Order order);
    public Order find(Integer orderID);
    public void cancel(Integer orderID);
}

Quando si implementa cancel (), è meglio consentire al client di chiamare prima find (id) per individuare l'ordine da cancellare, oppure è meglio aggiungere la logica al metodo cancel () per farlo, come segue :

List<Order> orders = new ArrayList<>();

public Order find(Integer orderID) throws OrderNotFoundException {
    Order order = orders.stream().filter(o->o.getId()==orderID) etc;
    if(order == null) {
        throw OrderNotFoundException();
    }
    return order;
}

public void cancel(Integer orderID) throws OrderNotFoundException {
    Order order = find(orderID);
    order.cancel();
}

O dovrei aggiungere la logica a OrderService, come segue:

public void cancelOrder(Integer orderID) {
    try{
        Order order = repo.find(orderID);
        if(order!=null) {
            order.cancel();
        }
    } catch(OrderNotFoundException e) {
        log error()
    }
}

E lascia il repository più semplice:

public Order find(Integer orderID)  {
    return orders.stream().filter(o->o.getId()==orderID) etc;
}

public void cancel(Integer orderID)  {
    Order order = find(orderID);
    order.cancel();
}

La domanda è: chi è la responsabilità di gestire gli ordini non trovati? Le eccezioni sono il modo migliore o dovrei usare Opzionale. Se uso facoltativo, l'utente non sa che l'ordine non esiste, solo che non è stato restituito.

Come ho detto, questo sembra essere un tema comune in cui mi sto imbattendo e che ho ampliato se dovessi seguire un modello di progettazione.