फ़ायरबेस जेनेरिक टाइप टाइप इंडिकेटर

Question

जेनेरिक प्रकार का उपयोग करते समय "अज्ञात प्रकार का सामना करना पड़ा" मैं जेनेरिक प्रकार के साथ कक्षा बनाने की कोशिश करता हूं जहां मैं इकाइयों की सूची पढ़ने के लिए फ़ंक्शन बनाता हूं। और मुझे पता है कि मेरे पास ऐसा करने के 2 तरीके हैं: (# 1) लूप में प्रत्येक इकाई को पढ़कर या (# 2) सीधे इकाइयों का नक्शा बनाएं।

2 रास्ता अधिक कुशल लग रहा है लेकिन दुर्भाग्य से GenericTypeIndicator सामान्य प्रकार के साथ काम नहीं करता है - यह IllegalStateException: Unknown type encountered: T लौटाता है जब मैं कोड में इसका इस्तेमाल करते हैं:

Map<String, T> entityMap = 
    dataSnapshot.getValue(new GenericTypeIndicator<Map<String, T>>() {}); 

तो:

1. वहाँ करने के लिए कोई तरीका है जेनेरिक प्रकार की इकाइयों को सीधे मानचित्र में पढ़ें? (# 2)
2. या बस लूप (# 1) में इकाइयों को पढ़ते समय प्रदर्शन में कोई महत्वपूर्ण अंतर नहीं है?

public class SomeClass<T extends KeyEntity> { 

    private final Class<T> mGenericClass; 
    private final String mRefKey; 

    public SomeClass(Class<T> clazz, String refKey) { 
     mGenericClass = clazz; 
     mRefKey = refKey; 
    } 

    public class KeyEntity { 
     private String mKey; 

     public KeyEntity() {} 

     public String getKey() { 
      return mKey; 
     } 

     public void setKey(String key) { 
      mKey = key; 
     } 
    } 

    public interface EntityListListener<T> { 
     abstract public void onEntityListLoaded(List<T> entity); 
    } 

    public void loadAll(final EntityListListener<T> entityListListener) { 
     DatabaseReference dbRef = FireDbUtils.getReference(mRefKey); 
     dbRef.addListenerForSingleValueEvent(new ValueEventListener() { 
      @Override 
      public void onDataChange(DataSnapshot dataSnapshot) { 
      List<T> entityList = new ArrayList<>((int) dataSnapshot.getChildrenCount()); 

      // #1 - read each entity in a loop 
      for (DataSnapshot childSnapshot : dataSnapshot.getChildren()) { 
       T entity = dataSnapshot.getValue(mGenericClass); 
       entity.setKey(childSnapshot.getKey()); 
       entityList.add(entity); 
      } 

      // #2 - read all entity into a map 
      // GenericTypeIndicator doesn't like generic type 
      // if used, it returns "IllegalStateException: Unknown type encountered: T" 
      Map<String, T> entityMap 
       = dataSnapshot.getValue(new GenericTypeIndicator<Map<String, T>>() {}); 
      for (Map.Entry<String, T> pair : entityMap.entrySet()) { 
       T entity = pair.getValue(); 
       entity.setKey(pair.getKey()); 
       entityList.add(entity); 
      } 

      entityListListener.onEntityListLoaded(entityList); 
     } 

     @Override 
     public void onCancelled(DatabaseError databaseError) {} 
    }); 
} 

जैसे। डेटा:

{ 
    carList: { 
     carKey1: { 
      name: "wife car" 
     }, 
     carKey2: { 
      name: "my best car in the world ever" 
     } 
    }, 
    garageList: { 
     garageKey1: { 
      name: "house garage" 
     }, 
     garageKey2: { 
      name: "top secret garage under main garage" 
     } 
    } 
} 

Answer 1

उपयोग ParameterizedType एक सामान्य वर्ग वस्तु को खोजने के लिए

ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass(); 
//all generic classes  
Type[] args = type.getActualTypeArguments(); 

Class<T> genericClass = (Class<T>) args[0]; 

T entity = dataSnapshot.getValue(genericClass);