Hallo! Aus dem Titel wird keiner schlau, fürchte ich - ich weiß einfach nicht, wie ich mein Problem kurz umschreiben kann… Also:

Ich arbeite grade an einer Anwendung, bei der mittels Hibernate und HSQLDB recht viele Klassen persistiert werden. Das funktioniert auch alles ganz gut, aber mir geht es ziemlich auf den Senkel, für jede zu persistierende Klasse Methoden für
- das Laden,
- das Speichern
- das Löschen
- …
eine Methode schreiben zu müssen, da es im Prinzip bei jeder Klasse immer das gleiche ist.

Also dachte ich mir, ich mach ne abstrakte Klasse, die oben genannte (statische) Methoden implementiert und von der alle zu persistierenden Klassen dann erben.

Mal am Beispiel der Methode zum Laden eines Landes nach dem String-Identifier:

So funktioniert es:
    public static Country getByIdentifier(String id)     {         Country instance = null;         Session s = ConnectionManager.getOfflineSession();         s.beginTransaction();         try         {             instance = (Country) s.get(Country.class, id);             s.getTransaction().commit();         }         catch (Exception e)         {             s.getTransaction().rollback();             ConnectionManager.getNewSession();         }         return instance;     }
und man kann es in die Superklasse einbauen, sodass es funktioniert: s. Anhang. (Sry, aber wenn ich den Code-Schnipsel hier einfügen will, krieg ich ne Fehlermeldung beim Posten xD )



Nun stellt sich aber ein Problem: Ich muss angeben, von welcher Klasse eine Instanz geladen werden soll - dazu das statische Feld someClass. Das Feld someClass will ich in jeder erbenden Klasse anders vergeben, also in Country dann "someClass = Country.class" - das funktioniert nur nicht.
Ohnehin scheint mir der Ansatz irgendwie um die Ecke gedacht, aber ich komm auf keine einfachere Lösung. (Im Grunde komm ich nich mal auf irgend eine funktionierende Lösung, bei der die Methoden komplett vererbt werden…)

Hat jemand ne Idee?


Danke!

Wolle

Der Rueckgabewert der Methode muss vermutlich ein Object sein. Die Aufrufende Methode weiss ja, was sie angefragt hat, und kann dann selbst Casten.

Der Country.class Teil aus "s.get(Country.class, id);" muss als Parameter uebergeben werden. Wieso du das in einer Klassenvariablen abspeichern moechtest erschliesst sich mir nicht.

Gruesse

X3K6A2

1. statt vererben ist statisch wohl einfacher!?
2. Du willst wohl Generalisierung verwernden!

Also etwa wie oben (fett = geändert):

class PersistenzManager {
public static < aType > aType getByIdentifier(String id, Class< ? extends aType> aClass)
    {
        aType instance = null;

        Session s = ConnectionManager.getOfflineSession();
        s.beginTransaction();

        try
        {
            instance = (aType) s.get(aClass, id);
            s.getTransaction().commit();
        }
        catch (Exception e)
        {
            s.getTransaction().rollback();
            ConnectionManager.getNewSession();
        }

        return instance;
    }
}

Durch den Aufruf weiss Java welche Klasse in den spitzen Klammern gemeint ist, hier wird aType zu Country:
Country land = PersistenzManager.getByIdentifier("D", Country.class);
Die elegante Lösung wird Fred sicher noch posten [10]

@X3:
1.) Ich fand das mit dem generischen Rückgabetyp praktisch.
2.) Ich will nicht jedes mal die Klasse als Parameter übergeben müssen =)

@Loom: Die Lösung hab ich auch gehabt, aba dann muss man ja immer die Klasse mit angeben und das will ich nich.

statische Methoden kann man nicht vererben,
es bleiben zur Vereinfachung zwei Möglichkeiten:

1.
Singleton oder einfache statische Variable:

Country.INSTANCE.getByIdentifer(x);

wobei die Klasse Country die nicht-statische Methode getByIdentifer() geerbt hat

2.
in jeder Klasse doch wieder eine einzelne Methode, aber eine ganz kurze einfache, die man bis auf Klassenname kopieren kann:

in Country:
public static Country getByIdentifier(String id) {
return (Country) CommonLoader.getByIdentifer(id, Country.class);
}

Na klar, das is alles möglich, aber es kommt mir einfach blöd vor, jedes mal nach dem Schema
"KlasseX.getByIdentifier(KlasseX.instance, id)" was aufrufen zu müssen - diesen Klassenparameter muss man doch irgendwie wegkriegen…

Und mit nem Singleton scheint mir ungeeignet, weil ich dann ja für jede zu persistierende Klasse ne LadeKlasse brauche, die dann Singleton is - denn ich will ja viele Country-Instanzen haben können.

wie gesagt reicht auch ein Objekt von vielen in einer statischen Variable, muss nicht das einzige sein,

du könntest auch eine zentrale Klasse nehmen und dort statische Variablen anlegen:
Main.COUNTRY.getById(); // COUNTRY ist ein Objekt der Klasse Country

so richtig schön wie
Country.getById()
ist es aber nicht zu erreichen,
es sei denn wiederum
COUNTRY.getById()
wobei COUNTRY eine statische Variable in einer Basisklasse ist, für alle Klassen die derartige Aufrufe benötigen ;)

ähnlich
getCountryLoader().getById()

Entitäten sind normalerweise nur einfache Containertypen, die Persistenzlogik wird in der Regel in Services ausgelagert.

Ansonste ließe sich das Beispiel von Loom auch generisch korrekt umsetzen:
class PersistenzManager { public static <T> T getByIdentifier(String id, Class< T extends RawPerformer> type)     {         T instance = null;         Session s = ConnectionManager.getOfflineSession();         s.beginTransaction();         try         {             instance = (T) s.get(type, id);             s.getTransaction().commit();         }         catch (Exception e)         {             s.getTransaction().rollback();             ConnectionManager.getNewSession();         }         return instance;     } }

Die elegante Lösung wird Fred sicher noch posten [10]

Danke für die Blumen, aber mir fällt auf Anhieb auch keine bessere Lösung ein als die Klasse zu übergeben. Generics sind in Java halt… naja, sagen mir mal nicht gerade besonders elegant.

OK, ich mach es jetzt mit einer Klasse, die die Persistenzlogik umsetzt, wie oben vorgeschlagen wurde.

Vielen Dank nochmal für die schnelle Hilfe =)

Ansonste ließe sich das Beispiel von Loom auch generisch korrekt umsetzen:
class PersistenzManager {     public static <T> T getByIdentifier(String id, Class< T extends RawPerformer> type) (...)

muss nicht die Typeinschränkung nach vorn? also

public static <T extends RawPerformer> T getByIdentifier(String id, Class<T> type)

yo, glaub ja

https://www.hibernate.org/328.html
http://www.ibm.com/developerworks/java/library/j-genericdao.html