Problem mit Generics und Interface

[norden]

Hallo,

Diese Info ist wahrscheinlich irrelevant, aber ich versuche ein singleton oject zu erstellen, welches als Pool für weitere Pools dienen soll.

Mein Problem:
Ich möchte eine Map mit verschiedenen GenericObjectPools haben. Diese GenericObjectPools müssen einen Type mitgegeben bekommen. Als Type möchte ich irgendetwas, was das Interface StorageClientAPI implementiert angeben. Also Quasi GenericObjectPool<? extends StorageClientAPI>.

Ich verstehe im Moment nicht, warum ich bei meinem Code in der Methode returnStorageClient einen Compiler Error erhalte..

Kann mir vielleicht irgendjemand behilflich sein?

import org.apache.commons.pool2.impl.GenericObjectPool;

public class StorageClientPoolPool {

	 private static StorageClientPoolPool instance = new StorageClientPoolPool();
	 
	 private HashMap<String, GenericObjectPool<? extends StorageClientAPI>> storageClientPools;
	 
	    /**
	     * Default-Konstruktor, der nicht außerhalb dieser Klasse
	     * aufgerufen werden kann
	     */
	    private StorageClientPoolPool() {}
	 
	    /**
	     * Statische Methode, liefert die einzige Instanz dieser
	     * Klasse zurück
	     */
	    public static StorageClientPoolPool getInstance() {
	        return instance;
	    }
	    
	    /**
	     * 
	     * Liefert einen StorageClient aus dem Pool
	     * 
	     */
	    public StorageClientAPI getStorageClient(String storageClientId) throws Exception {
	    	return (StorageClientAPI) storageClientPools.get(storageClientId).borrowObject();
	    }
	    
	    /**
	     * 
	     * Legt einen StorageClient zurück in den Pool
	     * 
	     */

	    public <T extends StorageClientAPI> void returnStorageClient(String storageClientId, T storageClient) {
	    	// ERROR: The method returnObject(capture#2-of ? extends StorageClientAPI) in the type 
                // GenericObjectPool<capture#2-of ? extends StorageClientAPI> is not applicable for the arguments (T)
               storageClientPools.get(storageClientId).returnObject(storageClient);
	    }
	    
	    /**
	     * 
	     * Fügt einen Pool hinzu
	     * 
	     */
	    public <T extends StorageClientAPI> void addStorageClientPool(String storageClientId, GenericObjectPool<T> storageClientPool) throws StorageClientPoolException {
	    	if(!storageClientPools.containsKey(storageClientId)) {
	    	storageClientPools.put(storageClientId, storageClientPool);
	    	}else {
	    		throw new StorageClientPoolException("A StorageClientPool with the ID " + storageClientId + " is still in the StorageClientPoolPool!");
	    	}
	    }
	
}

 

[Ch4t4r]

Generics ist meins Wissens nach in Methoden nicht möglich. Verwende dein T bei dem Klassenkopf und entsprechend in dem Konstruktor und es sollte gehen.

 

[Ruzmanz]

Habe mir jetzt keine Gedanken zum Sinn gemacht. Evtl. löst man das Problem ganz anders. Dein Fehler ist auf jeden Fall, dass dein "T" in der einen Klasse, nicht das "T" in der anderen Klasse sein muss. In deinem Beispiel funktionier es, aber das gilt sicherlich nicht für alle Fälle.

Ändern einfach mal deine returnObject-Methode folgendermaßen ab. Dann siehst du evtl. was ich meine:

	public T returnObject(Object abc) {
		try {
			return (T) abc;
		} catch(Exception ex) {
			return null;
		}
	}

 

[norden]

Hi,

danke für die Antworten.. ich habe es schon bevor ich es hier gelesen habe mithilfe des Klassenkopfes gemacht.. trotzdem danke Ch4t4r 😉

Leider tauchen jetzt überall Warnungen auf, da ich bei der Deklaration den Typ weglasse, aber kann man ignorieren, es funktioniert genau so, wie ich will.. Falls jemand ne bessere Lösung ohne Warnungen hat, wäre ich natürlich auch dankbar 😉

falls es interessiert, hier jetzt der Code..

import java.util.HashMap;

import org.apache.commons.pool2.impl.GenericObjectPool;

/**
 * The Class StorageClientPoolPool.
 * This pool is the container for StorageClientAPIPools.
 * Its a singleton Object.
 * The single instance of this pool can be acquired by calling this: StorageClientPoolPool pool = StorageClientPoolPool.getInstance()
 *
 * @author Marcel Richter
 * @param <T> no parameter needed
 */
public class StorageClientPoolPool<T extends StorageClientAPI> {

	 /** The instance. */
 	private static StorageClientPoolPool instance = new StorageClientPoolPool();
	 
	 /** The storage client pools. */
 	private HashMap<String, GenericObjectPool<T>> storageClientPools = new HashMap<String, GenericObjectPool<T>>();
	 
	    /**
    	 * Default-Konstruktor, der nicht außerhalb dieser Klasse
    	 * aufgerufen werden kann.
    	 */
	    private StorageClientPoolPool() {}
	 
	    /**
    	 * Statische Methode, liefert die einzige Instanz dieser
    	 * Klasse zurück.
    	 *
    	 * @return single instance of StorageClientPoolPool
    	 */
	    public static StorageClientPoolPool getInstance() {
	        return instance;
	    }
	    
	    /**
    	 * Liefert einen StorageClient aus dem Pool.
    	 *
    	 * @param storageClientId the id of the StorageClientPool
    	 * @return the StorageClient
    	 * @throws Exception if something goes wrong in the constructor of the storageClient
    	 */
	    public StorageClientAPI getStorageClient(String storageClientId) throws Exception {
	    	return (StorageClientAPI) storageClientPools.get(storageClientId).borrowObject();
	    }
	    
	    /**
    	 * Legt einen StorageClient zurück in den Pool.
    	 *
    	 * @param storageClientId the id of the StorageClientPool
    	 * @param storageClient the storage client
    	 * @throws StorageClientPoolException if the pool with given ID doesnt exist
    	 */
	    public void returnStorageClient(String storageClientId, T storageClient) throws StorageClientPoolException {
	    	if(this.storageClientPools.containsKey(storageClientId)) {
	    		storageClientPools.get(storageClientId).returnObject(storageClient);
	    	}else {
	    		throw new StorageClientPoolException("StorageClientPool with ID: " + storageClientId + " does not exist!");
	    	}
	    }
	    
	    /**
    	 * Fügt einen Pool hinzu.
    	 *
    	 * @param storageClientId the id of the StorageClientPool
    	 * @param storageClientPool the storage client pool
    	 * @throws StorageClientPoolException if there allready is an pool with given ID
    	 */
	    public void addStorageClientPool(String storageClientId, GenericObjectPool<T> storageClientPool) throws StorageClientPoolException {
	    	if(!storageClientPools.containsKey(storageClientId)) {
	    	storageClientPools.put(storageClientId, storageClientPool);
	    	}else {
	    		throw new StorageClientPoolException("A StorageClientPool with the ID " + storageClientId + " is still in the StorageClientPoolPool!");
	    	}
	    }
	    
	    /**
    	 * Exist storage client pool.
    	 *
    	 * @param storageClientId the id of the StorageClientPool
    	 * @return true, if exist
    	 */
    	public boolean existStorageClientPool(String storageClientId) {
	    	return this.storageClientPools.containsKey(storageClientId);
	    }
	
}

das ganze rufe ich dann beispielsweise so auf:

//Instanz des StorageClientPoolPool besorgen
StorageClientPoolPool poolPool = StorageClientPoolPool.getInstance(); 

//Factory zum StorageClientPoolPool hinzufügen
GenericObjectPool<TestAPI1> pool1 = new GenericObjectPool<TestAPI1>(new TestAPI1PooledObjectFactory(), config);
poolPool.addStorageClientPool("1", pool1);

//StorageClient aus dem pool holen und nach benutzung zurücklegen
StorageClientAPI storageClientAPI1 = poolPool.getStorageClient("1");
//benutzen
//zurücklegen
poolPool.returnStorageClient("1", storageClientAPI1);

 

[arilou]

Anmerkung: Guter Code ist komplett Warnungs-frei (oder fast).
Zumindest sollte der Programmierer bei jeder Warnung wissen, warum sie nicht vermieden werden kann.
Und "zu faul das zu ändern"/"keine Zeit" zählt nicht.

Es gibt in den meisten Editoren übrigens auch eine Funktion namens "Suchen & Ersetzen" ~ sie wartet darauf, dass du sie einsetzt...