Java - Modèles d'usine et de stratégie avec des génériques

Question

J'essaie d'implémenter un pattern Strategy + Factory en utilisant des génériques. Le but est de retourner à une classe client une implémentation de l'interface DocumentDao qui peut gérer un document de type T extends, donc j'ai plusieurs interfaces Dao qui étendent DocumentDao pour différents sous-types de Document.

Voici mon code:

public class Document { ... } 

public class DocumentA extends Document { ... } 

public class DocumentB extends Document { ... } 

public interface DocumentDao<T extends Document> { 
    public void update(T document); 
} 

public interface DocumentADao<DocumentA> {} 

public interface DocumentDaoFactory { 
    public <T extends Document> DocumentDao<T> getDaoInstance(Class<T> clazz); 
} 

Ensuite, je tente d'utiliser l'usine:

private <T extends Document> void someMethod(T document) { 
    ... 
    DocumentDao<T> documentDao = this.documentDaoFactory.getDaoInstance(document.getClass()); 
    documentDao.update(document); 
    ... 
} 

Mais les plaintes du compilateur au sujet de la getDaoInstance() appel:

Type mismatch: cannot convert from DocumentDao<? extends AbstractGDriveDocument<?>> to DocumentDao<T> 

Comment pour faire face à cette situation? Comment puis-je obtenir une solution similaire?

Merci

Answer 1

Le problème est que getClass est un retour Class<?>, qui est approprié pour l'API; il ne sait pas quelle instance spécifique Class ramener. De plus, votre type lié est incorrect et invalide dans votre méthode.

Pour résoudre ce problème, vous devez changer deux choses:

• Dans votre méthode DocumentDaoFactory, changer la limite appropriée.

  <T extends Document> DocumentDao<T> getDaoInstance(Class<T> clazz); 
  

• Dans votre utilisation de getDaoInstance, effectuer une distribution non contrôlée à Class<T>.

  DocumentDao<T> documentDao = this.documentDaoFactory.getDaoInstance((Class<T>) document.getClass()); 
  

La façon dont vos types sont liés devrait vous redonner les instances qui vous passionnent, sans avoir des erreurs d'exécution.