qual è il modo corretto di organizzare il codice che si trova a cavallo di più oggetti?

2

Diciamo che ho le seguenti classi: person, widget, foo_bars.

Una persona può avere più widget e foo_bars.

Quando un amministratore cancella una persona, voglio che il mio codice esegua un'eliminazione a catena ... e rimuova tutti i record correlati nel database per questa persona Nella mia classe widget, ho un metodo di cancellazione ... e lo stesso vale per la mia classe foo_bars

Ma per soddisfare qualcosa come la funzione di eliminazione della persona, mi sento come se dovessi creare la classe "Person Manager", che in realtà ripeterà una versione tutta la logica all'interno di entrambi i metodi di cancellazione nelle classi widget / foo_bars. (invece di chiamare semplicemente i metodi esistenti sulle classi.

Ecco cosa sto pensando:

Esempio 1

 public class PersonManager{

     delete_person(personID as int)
     { 
        // assume that I've queried for list of all widget and foobars IDs.
        //1.  delete all widgets for personID
        success = true
        dim obj_widget = new widget;
        loop through all widgets  
            result = obj_widget.delete(widgetID)   
            if not result then
               success = false 
               exit with error
            end if  
        end loop 

        //2.  delete all foo bars for personID
        if success then 
            dim objfoobar= new foo_bars;
            loop through all foobars
                result = objfoobar.delete(foobarid)    
                 if not result then
                    success = false
                    exit loop
                  end  
            end loop 
         end 

        //3. delete person record. 
        if success then 
             result = databaseobj.deleteperson(personID)
             if not result then 
                 return false, "Delete person failed because...."
             else
                 return true
             end                
        end 
     }
 }

Nell'esempio sopra, sto cercando di dimostrare il riutilizzo di esistenti i metodi di cancellazione esistenti su ogni classe ... e poi se cancella con successo tutti i widget e i foobar per la persona, allora cancello il record della persona stessa.

Il problema con questo è che se i widget si eliminano correttamente, ma le barre di foo non lo fanno, come faccio a eseguire il rollback? Ogni metodo di eliminazione ha la propria transazione definita all'interno, poiché l'eliminazione di un widget o di una barra del foo implica, diciamo 2 - 3 passaggi. Quindi, in altre parole, il metodo di eliminazione sulla classe del widget è attualmente simile a questo:

    public class widget{
         delete_widget{
                 database.execute("BEGIN TRANSACTION")
                 database.execute("DELETE FROM XYX ...")
                 if successful then 
                        database.execute("DELETE FROM yyy...")
                 else 
                        database.execute("ROLL BACK")
                        return false
                 end if
                 database.execute("COMMIT")
                 return true
              }
      }

Per ogni widget, chiamerò questo metodo ... Che cosa succede se tutti i widget eliminano, ma muore cancellando il primo foobar? Penso di dover riscrivere il codice per eliminare tutto ciò che è giusto all'interno della classe Person manager e avvolgerlo in una transazione, invece di chiamare i metodi di eliminazione esistenti nelle classi. Almeno, questo è quello che sto pensando. Se c'è un altro modo per vedere questo problema, per favore fatemelo sapere. Potrei semplicemente scrivere un'istruzione SQL di eliminazione a cascata nella classe PersonManager e non chiamare i metodi sulle due classi. Ma non so se l'utilizzo di cancellazioni a cascata SQL è una buona cosa ... Grazie!

    
posta dot 27.12.2013 - 22:26
fonte

1 risposta

1

Quindi il tuo problema sono transazioni nidificate. Penso che questo possa essere risolto separando la logica della transazione dalla logica dei dati.

Qualcosa come Pattern di comando , dove i comandi rappresentano le operazioni e quello che esegue il comando è responsabile delle transazioni è buono in forma. Potresti anche comporre bene i comandi di varie eliminazioni. E persino i brutti test e impostazioni di successo potrebbero essere ben codificati in alcuni specifici comandi compositi che gestiscono la logica del successo.

    
risposta data 27.12.2013 - 22:48
fonte

Leggi altre domande sui tag