Manière la plus efficace de refléter la relation d'héritage dans les DAO?

Question

Travail sur une application métier utilisant la structure MVC et une architecture Business Object/DAO. Pour tout objet métier normal, les fonctions CRUD sont assez simples. Mais quelle est la meilleure façon de gérer une relation parent-enfant comme "Le client est un utilisateur"?

Je sais que les classes suivantes:

User, UserDAO, Customer, CustomerDAO 

La Customer classe peut hériter de la User très bien, mais comment voulez-vous mieux tenir compte dans les fonctions DAO CRUD?

Answer 1

Martin Fowler a documenté quelques Object-Relational Structural Patterns qui pourraient aider:

1) Single Table Inheritance: Représente une hiérarchie d'héritage des classes comme une seule table qui a des colonnes pour tous les champs des différentes classes.

par exemple. Employee et Customer héritent tous les deux de User et sont tous deux stockés dans la table User, avec une colonne qui détermine le type d'utilisateur qu'un enregistrement particulier représente.

2) Class Table Inheritance: Représente une hiérarchie d'héritage de classes avec une table pour chaque classe.

par exemple. Employee et Customer héritent toutes deux de User et il y a trois tables pour représenter ceci. La table Utilisateur stocke les propriétés communes à tous les utilisateurs. La table Employee a un pointeur vers la table User et stocke uniquement les propriétés pertinentes pour Employees. La même chose est vraie de la table Customer.

3) Concrete Table Inheritance: Représente une hiérarchie d'héritage de classes avec une table par classe concrète dans la hiérarchie.

par exemple. Employee et Customer héritent tous les deux de la classe abstraite User et il y a deux tables pour le représenter. Une table Customer et une table Employee. Chaque table stocke des informations communes aux utilisateurs, mais stocke également des propriétés uniques.

Answer 2

Vous pouvez avoir une instance de UserDAO dans CustomerDAO. Vous devez interagir avec les tables User et Customer pour couvrir les colonnes de la classe de base et de la sous-classe. Par exemple:

public class CustomerDAO 
{ 
    UserDAO userDao; 

    // ... initialization ... 

    public void update(Customer customer) 
    { 
     // ... first execute update of customer table ... 

     userDao.update(customer); // Should be able to pass Customer to UserDAO due to inheritance 
    } 

    public void insert(Customer customer) 
    { 
     // First insert a row in the User table so that the ID of the user can be determined. 
     userDao.insert(customer); 

     // ... Now execute insertion of row into Customer table ... 
    } 

    public void delete(Customer customer) 
    { 
     // ... first delete Customer row ... 

     // Now delete base class User row. 
     userDao.delete(customer); 
    } 
} 

Bien sûr, chaque opération client devrait probablement être enveloppé dans une transaction afin que la mise à jour des tables de l'utilisateur et le client ne manque pas de manière indépendante.