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!