DAO e inyección de dependencia, ¿consejo?

This is the first time im using the DAO pattern. From what I've leer so far, implementing this pattern will help me seperate my calling code (controller) from any persistence implementation - exactly what I want; that is, I don't want to be restrcited to the use of any particular database or 3rd party libraries.

I'm creating some test code (in TDD fashion) using MongoDB and morphia (as an example), with morphia's provided BasicDAO clase.

As far as I can tell, extending BasicDAO<T, V> requires a constructor that accepts Morphia and Mongo objects; these are very specific (3rd party) types that I don't really want floating around outside of the DAO class itself.

How can I have more of a pluggable architecture? By this I mean, what should I look into re being able to configure my application to use a specific DAO with specific configuration arguments, external to the actual source?

preguntado el 08 de noviembre de 11 a las 11:11

4 Respuestas

A "pluggable" DAO layer is usually/always based on an interface DAO. For example, lets consider a quite generic simple one:

public interface GenericDAO <T, K extends Serializable> {  
    List<T> getAll(Class<T> typeClass);   
    T findByKey(Class<T> typeClass, K id);  
    void update(T object);  
    void remove(T object);  
    void insert(T object);  
}

(This is what you have in Morphia's generic DAO)

Then you can develop different several generic DAO implementations, where you can find different fields (reflected in constructor parameters, setters and getters, etc). Let's assume a JDBC-based one:

public class GenericDAOJDBCImpl<T, K extends Serializable> implements GenericDAO<T, K extends Serializable> {
    private String db_url;

    private Connection;
    private PreparedStatement insert;
    // etc.
}

Once the generic DAO is implemented (for a concrete datastore), getting a concrete DAO would be a no brainer:

public interface PersonDAO extends GenericDAO<Person, Long> {

}

y

public class PersonDAOJDBCImpl extends GenericDAOJDBCImpl<Person, Long> implements PersonDAO {

}

(BTW, what you have in Morphia's BasicDAO is an implementation of the generic DAO for MongoDB).

The second thing in the pluggable architecture is the selection of the concrete DAO implementation. I would advise you to read chapter 2 from Apress: Pro Spring 2.5 ("Putting Spring into "Hello World") to progressively learn about factories and dependency injection.

respondido 08 nov., 11:15

+1 for this. I'd add that Guice is the DI framework we're using with great succes. - Remon van Vliet

Spring does DI for you using configurations and it's widely used.

respondido 12 nov., 11:20

Hi i am not an expert in java. but trying to give a solution.

you can have a superclass where all the connection related stuff happens and any other base class where you can extend and use it.

Later any switch in your DB for specific 3rd party drivers you can rewrite the superclass.

Again I am no expert. Just trying around here to learn. :)

respondido 12 nov., 11:20

A couple standard DI frameworks are Spring and Guice. Both these frameworks facilitate TDD.

respondido 08 nov., 11:15

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.