Design-Frage: persistent machen per Reflection

[nebulo]

Hallo,

ich weiß nicht ob das hier unbedingt der richtige Ort ist, weiß aber kein bessern. Tatsächlich hat meine Frage auch nicht sehr viel mit Java an sich zu tun.

Ich will mein Datenmodell radikal vereinfachen. 2 Gründe habe ich dafür. Zum ersten ist meine Anwendung ich würde sagen Service orientiert. D.h. es gibt verschiedene Services die mit den Daten des Datenmodells verschiedene Dinge tun. Außerdem habe ich momentan einfach das Gefühl, dass das die Datenklassen zu aufgebläht sind.

Jetzt zu meiner Idee. Ich will das die Daten eine Schnittstelle implementieren. Die Datenobjekte sollen mittels der im Interface deklarierten Methode, die Methodennamen zurückgeben, deren Rückgabe persitent gemacht werden sollen. Per Reflection werden dann diese Daten abgefragt und in die Datenbank geschrieben. Was haltet ihr von der Idee?

Wiegesagt momentan ist es nur eine Idee, ich wäre dankbar für ein paar Meinungen dazu. Schließlich sieht man in einer eigenen Idee oft nur die Stärken und nicht die Schwächen.

Gruß nebulo

 

[Murray]

Jetzt zu meiner Idee. Ich will das die Daten eine Schnittstelle implementieren. Die Datenobjekte sollen mittels der im Interface deklarierten Methode, die Methodennamen zurückgeben, deren Rückgabe persitent gemacht werden sollen. Per Reflection werden dann diese Daten abgefragt und in die Datenbank geschrieben. Was haltet ihr von der Idee?

Meinst du das in etwa so:

public interface Persistent {
  public String[] getMethodNames();
}

public class Data implements Persistent {
  //--- x1 soll persistentioniert werden
  public int x1() {
     /* .. */
  }
  //--- x2 soll nicht persistentioniert werden
  public int x2() {
     /* .. */
  }

  public String[] getMethodNames() {
    return new String[]{ "x1"};
  }  
}

Dann schon lieber direkt die Method-Objekte liefern lassen:

public interface Persistent {
  public Method[] getMethods() throws Exception;
}

public class Data implements Persistent {
  //--- x1 soll persistentioniert werden
  public int x1() {
     /* .. */
  }
  //--- x2 soll nicht persistentioniert werden
  public int x2() {
     /* .. */
  }

  public Method[] getMethods() throws Exception{
    return new Method[]{ this.getClass().getDeclaredMethod( "x1")};
  }  
}

Noch besser: statt Interface Annotation verwenden:

public class Data {

  @Retention(RetentionPolicy.RUNTIME)
  @java.lang.annotation.Target(ElementType.METHOD)
  public @interface Persitent{
  }

  //--- x1 soll persistentioniert werden
  @Persitent
  public int x1() {
     /* .. */
  }

  //--- x2 soll nicht persistentioniert werden
  public int x2() {
     /* .. */
  }

}

Wenn du aber ohnehin gerade dabei bist, die Anwendung umzustrukturieren: vielleicht siehst du dir noch fertige Persistenz-Frameworks (z.B. Hibernate) an.

 

[Niki]

Ich habe soetwas schon des öfteren implementiert. Der große Nachteil von Reflection zur Laufzeit ist, dass es sehr langsam ist. Ich habe mir daher einen Generator geschrieben der mir aus der Datenbank zu einem Schema die Tabellen ausliest, und die dazugehörigen Data Access Objects + POJOs generiert. Die DAOs implementieren abstrakte Methoden wie fillPojo, fillStatementFromPojo, getTableName, getDbFields, getPrimaryKeyWhereClause, fillPrimaryKeyWhereClause,...
In der abstrakten Superklasse befinden sich Methoden wie insert, update, delete, select,...
Da ich dieses Mini-Persistence-Framework für eine Firma implementiert habe befürchte ich, dass ich weder den Code posten noch schicken kann
Ich hoffe aber trotzdem dass ich dir helfen konnte. Falls du wissen willst wie man aus der DB die notwendigen Informationen holt schau dir das Interface DatabaseMetaData an

 

[nebulo]

Danke, ich habe jetzt zumindest ein paar neue Ansatzpunkte. Ich werde mich mal näher mit DAO/SDO beschäftigen und dann überlegen wie ich das, ich nenne es mal Persistenz-Layer, kapsle. So wie das Design jetzt ist will ich es jedenfalls auf keinen Fall lassen.

Gruß nebulo