Les Modèles de conception pour la Couche d'Accès aux Données

Bien, l'approche commune pour le stockage de données en java est, comme vous l'avez remarqué, pas du tout très orienté-objet. C'est en soi ni bonne ni mauvaise: "l'objet-orienté" n'est ni un avantage, ni inconvénient, c'est juste l'un des nombreux paradigmes, qui aide parfois avec une bonne conception de l'architecture (et parfois pas).

La raison DAOs en java ne sont pas généralement orientée objet est exactement ce que vous voulez obtenir de détendre votre dépendance sur la base de données spécifique. Mieux conçu langue, qui a permis à l'héritage multiple, c', ou bien sûr, peut être fait très élégante dans une méthode orientée objet, mais avec java, il semble juste être plus d'ennuis que cela vaut la peine.

Dans un sens plus large, la non-OO approche permet de découpler au niveau de l'application des données de la manière dont elles sont stockées. C'est plus de la (non) la dépendance sur les spécificités d'une base de données particulière, mais aussi le stockage des schémas, ce qui est particulièrement important lors de l'utilisation de bases de données relationnelles (ne me lancez pas sur ORM): vous pouvez avoir un schéma relationnel parfaitement traduit dans l'application OO modèle par votre DAO.

Donc, ce que la plupart des DAOs sont en java sont aujourd'hui essentiellement ce que vous avez mentionné dans le début des classes, plein de méthodes statiques. Une différence est que, au lieu de faire toutes les méthodes statiques, il est préférable d'avoir un seul statique de la "méthode de fabrique" (probablement, dans une classe différente), qui renvoie un (singleton) instance de votre DAO, qui implémente une interface particulière, utilisée par le code de l'application pour accéder à la base de données:

public interface GreatDAO {
    User getUser(int id);
    void saveUser(User u);
}
public class TheGreatestDAO implements GreatDAO {
   protected TheGeatestDAO(){}
   ... 
}
public class GreatDAOFactory {
     private static GreatDAO dao = null;
     protected static synchronized GreatDao setDAO(GreatDAO d) {
         GreatDAO old = dao;
         dao = d;
         return old;
     }
     public static synchronized GreatDAO getDAO() {
         return dao == null ? dao = new TheGreatestDAO() : dao;
     }
}

public class App {
     void setUserName(int id, String name) {
          GreatDAO dao =  GreatDAOFactory.getDao();
          User u = dao.getUser(id);
          u.setName(name);
          dao.saveUser(u);
     }
}

Pourquoi le faire de cette façon, par opposition à des méthodes statiques? Eh bien, que si vous décidez de passer à une autre base de données? Naturellement, vous devez créer une nouvelle classe DAO, la mise en œuvre de la logique de votre stockage. Si vous avez été en utilisant des méthodes statiques, vous avez maintenant à passer à travers tout votre code, l'accès à la DAO et de la modifier pour l'utilisation de votre nouvelle classe, non? Ce pourrait être une grande douleur. Et si ensuite vous changez d'avis et que vous voulez revenir à l'ancienne db?

Avec cette approche, tout ce que vous devez faire est de modifier le GreatDAOFactory.getDAO() et la faire de créer une instance d'une autre classe, et tout le code de votre application sera à l'aide de la nouvelle base de données sans aucune modification.

Dans la vraie vie, cela se fait souvent sans modification du code: l'usine méthode est la mise en œuvre nom de la classe par l'intermédiaire d'un paramètre de propriété, et il instancie l'aide de la réflexion, donc, tout ce que vous devez faire pour passer des implémentations, modifier un fichier de propriétés. Il ya effectivement des cadres - comme spring ou guice - ce "l'injection de dépendance" mécanisme pour vous, mais je n'entrerai pas dans les détails, d'abord, parce qu'il est vraiment au-delà de la portée de votre question, et aussi, parce que je ne suis pas forcément convaincu que les avantages que vous obtenez à partir de l'utilisation de ces cadres en vaut la peine intégration avec eux pour la plupart des applications.

L'autre (probablement plus de chances d'être pris avantage de) l'avantage de cette "usine approche" par opposition à la statique est la capacité de test. Imaginez que vous écrivez un test unitaire, qui doit tester la logique de votre App classe indépendamment de toute DAO sous-jacent. Vous ne voulez pas utiliser tout réel de stockage sous-jacent pour plusieurs raisons (vitesse, d'avoir à mettre en place, et nettoyer par la suite, d'éventuelles collisions avec d'autres tests, possibilité de polluer les résultats de test avec des problèmes dans DAO, rien à voir avec App, qui est actuellement mis à l'épreuve, etc.).

Pour ce faire, vous voulez un framework de test, comme Mockito, qui permet de "se moquer de" la fonctionnalité d'un objet ou d'une méthode, en le remplaçant par un "dummy" de l'objet, avec des comportement (je vais passer les détails, parce que, là encore, au-delà de la portée). Ainsi, vous pouvez créer ce mannequin objet le remplacement de votre DAO, et de faire de la GreatDAOFactory retourner votre mannequin à la place de la vraie chose en appelant GreatDAOFactory.setDAO(dao) avant le test (et de les restaurer après). Si vous avez été en utilisant des méthodes statiques au lieu de l'instance de la classe, ce ne serait pas possible.

Un autre avantage, qui est un peu similaire à la commutation de bases de données que j'ai décrit ci-dessus est "proxénétisme" votre dao avec des fonctionnalités supplémentaires. Supposons que votre application devient plus lente que la quantité de données dans la base de données augmente, et que vous décidez que vous avez besoin d'un cache couche. Mettre en œuvre une classe wrapper, qui utilise le réel dao instance (fournis comme un constructeur de param) pour accéder à la base de données, et met en cache les objets qu'il lit dans la mémoire, de sorte qu'ils peuvent être rendus plus rapide. Vous pouvez alors faire votre GreatDAOFactory.getDAO instancier ce wrapper, pour l'application de profiter de il.

(Ce qui est appelé "délégation " modèle" ... et il semble comme une douleur dans le cul, surtout quand vous avez beaucoup de méthodes définies dans votre DAO: vous aurez à mettre en œuvre tous dans l'emballage, même à modifier le comportement d'un seul. Alternativement, vous pouvez simplement sous-classe votre dao, et ajouter la mise en cache de cette façon. Ce serait beaucoup moins ennuyeux codage initial, mais peut devenir problématique lorsque vous décidez de changer la base de données, ou, pire, d'avoir une option de commutation implémentations d'avant en arrière.)

Un tout aussi largement utilisés (mais, à mon avis, inférieur) alternative à la "fabrique" de la méthode est de faire le dao une variable de membre dans toutes les classes qui en ont besoin:

public class App {
   GreatDao dao;
   public App(GreatDao d) { dao = d; }
}

De cette façon, le code qui instancie ces classes doit instancier l'objet de dao (pourrait toujours utiliser de l'usine), et de l'offrir comme un paramètre du constructeur. L'injection de dépendance cadres je l'ai mentionné ci-dessus, généralement de faire quelque chose de semblable à cela.

Cette offre tous les avantages de la "fabrique" méthode d'approche, que j'ai décrit plus tôt, mais, comme je l'ai dit, n'est pas aussi bon à mon avis. Les inconvénients sont ici d'avoir à écrire un constructeur pour chacune des classes de votre application, en faisant exactement la même chose encore et encore, et également ne pas être en mesure d'instancier les classes facilement en cas de besoin, et certains ont perdu plus de lisibilité: avec une assez grande base de code, d'un lecteur de code, pas familier avec elle, va avoir du mal à comprendre la mise en œuvre de la dao est utilisé, comment il est instancié, si c'est un singleton, un thread-safe mise en œuvre, qu'il garde de l'état, ou caches quelque chose, la façon dont les décisions sur le choix d'une mise en oeuvre particulière sont prises etc.

OriginalL'auteur Dima