Een "pluggable" DAO-laag is meestal/altijd gebaseerd op een interface-DAO. Laten we bijvoorbeeld een vrij algemene simpele beschouwen:
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);
}
(Dit is wat je hebt in Morphia's generieke DAO )
Vervolgens kunt u verschillende generieke DAO-implementaties ontwikkelen, waar u verschillende velden kunt vinden (weerspiegeld in constructorparameters, setters en getters, enz.). Laten we aannemen dat er een op JDBC is gebaseerd:
public class GenericDAOJDBCImpl<T, K extends Serializable> implements GenericDAO<T, K extends Serializable> {
private String db_url;
private Connection;
private PreparedStatement insert;
// etc.
}
Zodra de generieke DAO is geïmplementeerd (voor een concrete datastore), zou het een goed idee zijn om een concrete DAO te krijgen:
public interface PersonDAO extends GenericDAO<Person, Long> {
}
en
public class PersonDAOJDBCImpl extends GenericDAOJDBCImpl<Person, Long> implements PersonDAO {
}
(BTW, wat je hebt in Morphia's BasicDAO is een implementatie van de generieke DAO voor MongoDB).
Het tweede ding in de pluggable architectuur is de selectie van de concrete DAO-implementatie. Ik raad je aan om hoofdstuk 2 te lezen van Apress:Pro Spring 2.5 ("De lente in "Hallo wereld brengen") om geleidelijk meer te leren over fabrieken en afhankelijkheidsinjectie.