Dependecy Injection des collections

Question

J'ai une classe A qui fonctionne avec List<String>. Mais personne en dehors de cette classe ne devrait avoir besoin de savoir que cela fonctionne avec des cordes. Cependant, je veux aussi fournir l'implémentation concrète que la classe devrait utiliser pour List (via l'injection de dépendance).

A devrait ressembler à ceci

public class A { 
    private ListFactory listFactory; //this gets injected from the outside 

    public A(ListFactory listFactory) { 
    this.listFactory = listFactory; 
    } 

    public void a() { 
    List<String> = listFactory.createList(); 
    //... 
    } 
} 

Et la classe appelant B quelque chose comme ça

public class B { 
    public void b() { 
    ListFactory factory = new ArrayListFactory(); //we want class A to use ArrayList 
    A a = new A(factory); 
    //... 
    } 
} 

ListFactory serait une interface qui est mis en œuvre par ArrayListFactory pour créer ArrayList s.

Quintessence: Je ne veux pas que B doit mentionner quelque part String. Et je ne veux pas non plus que A doit mentionner ArrayList quelque part.

Est-ce possible? Et comment regarder ListFactory et ArrayListFactory?

Answer 1

C'est plus simple que vous faites, je pense:

public interface Factory { 
    public <T> List<T> create(); 
} 

public class FactoryImpl implements Factory { 
    public <T> ArrayList<T> create() { 
     return new ArrayList<T>(); 
    } 
} 

... 
Factory f = new FactoryImpl(); 
List<String> strings = f.create(); 
... 

Answer 2

Semble que vous avez écrit tout ce dont vous avez besoin. Les usines ressembleront:

interface ListFactory<K, T extends List<K>> { 
    T create(); 
} 

class ArrayListFactoryImpl implements ListFactory<String, ArrayList<String>> { 
    public ArrayList<String> create() { 
     return new ArrayList<String>(); 
    } 
} 

class Sample { 
     public static void main(String[] args) { 
      ListFactory<String, ArrayList<String>> factory = new ArrayListFactoryImpl(); 
      factory.create().add("string"); 
     } 
} 

Answer 3

Une autre tentative grâce à plus claire compréhension de la question:

interface ListFactory<T extends List> { 
    T create(); 
} 

class ArrayListFactoryImpl implements ListFactory<ArrayList> { 
    public ArrayList create() { 
     return new ArrayList(); 
    } 
} 

class ListWrapper<T> implements List<T> { 
    private final List impl; 

    public ListWrapper(List impl) { 
     this.impl = impl; 
    } 

    public boolean add(T t) { 
     if (!String.class.isAssignableFrom(t.getClass())) 
      throw new RuntimeException("Aaaaa"); 
     return impl.add(t); 
    } 

    // so on... 
} 

class A { 
    A(ListFactory factory) { 
     List<String> stringsOnly = new ListWrapper<String>(factory.create()); 
    } 
} 

class Sample { 
     public static void main(String[] args) { 
      ListFactory<ArrayList> factory = new ArrayListFactoryImpl(); 
      new A(factory); 
     } 
}