JAVA: Statisches Feld in mehreren Klassen + Common Interface

Question

Gibt es eine Möglichkeit des Setup in JAVA folgenden Konstruktion:

• eine gemeinsame Schnittstelle oder Basisklasse mit
• einem statischen öffentlichen Bereich durch die gemeinsame erklärt hat Schnittstelle
• jedes Modell die gemeinsame Schnittstelle implementieren sollte eigene statische Feld (nicht einer gemeinsamen Instanz für alle Modelle)

Ausführliche Erklärung: Ich arbeite mit ORMLite und muss die ForeignCollections meiner Modelle nach der Deserialisierung aktualisieren. Dafür muss ich von den Modellen einen Verweis auf meine DAO haben, was ich nicht möchte.

So kam ich mit folgendem Konzept bis:

• halten ein statisches Feld in jedem der Modelle der folgenden Schnittstellen:

  public interface SerializableObserver { 
      void onAfterDeserialization(Object object); 
  } 
  

• in meiner Implementierung von private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException nach dem Lesen In allen Ivars rufe ich die onAfterDeserialization -Methode des statischen Feldes, das ich im Modell halte.

  • Im Dao stelle ich das statische Feld des Modells ein. Wenn die Deserialisierung beendet ist, wird eine Methode in meinem Dao aufgerufen. Wo kann ich schließlich die ForeignCollection aktualisieren, damit sie nach der Deserialisierung noch gültig ist.

Also, was ich suche, ist eine Art und Weise etwas allgemeinere so diese ganze Ansatz zu machen, muss ich dieses Verhalten für alle meine 20 Modelle nicht implementieren. Und schließlich wird dies eine Android-App sein. also keine schicken Java-8-Dinge.

Answer 1

Ich würde eine andere Klasse verwenden, die Modellklassen auf SerializableObserver-Implementierungen abbildet. Zum Beispiel

DeserializerMap:

public enum DeserializerMap { 

    INSTANCE; 

    private Map<Class<? extends Model>, SerializableObserver> modelObserverMap = new HashMap<>(); 

    public void registerSerializableObserver(Class<? extends Model> modelClass, SerializableObserver serializableObserver) { 
     modelObserverMap.put(modelClass, serializableObserver); 
    } 

    public void deregisterSerializableObserver(Class<? extends Model> modelClass) { 
     modelObserverMap.remove(modelClass); 
    } 

    public SerializableObserver getSerializableObserver(Class<? extends Model> modelClass){ 
     return modelObserverMap.get(modelClass); 
    } 

} 

Modellklasse:

public class ModelClass implements Model{ 

    private int id; 

    public ModelClass(int id) { 
     this.id = id; 
    } 

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException{ 
     ois.defaultReadObject(); 
     DeserializerMap.INSTANCE.getSerializableObserver(this.getClass()). 
       onAfterDeserialization(this); 
    } 
} 

Das "Modell" Schnittstelle nur Serializable erstreckt und in DeserializerMap verwendet wird, aber man kann nur an der Schnittstelle loswerden und verwenden Class<? extends Object> anstelle von Class<? extends Model> in DeserializerMap,

Modell:

public interface Model extends Serializable{ 
} 

DAO Klasse:

public class DAOClass { 

    public DAOClass(){ 
     SerializableObserver serializableObserver = new SerializableObserver() { 
      @Override 
      public void onAfterDeserialization(Object object) { 
       System.out.println("After deserialization"); 
       anotherMethod(); 
      } 
     }; 
     DeserializerMap.INSTANCE.registerSerializableObserver(ModelClass.class, serializableObserver); 
    } 

    public void anotherMethod(){ 
     System.out.println("another method"); 
    } 
} 

, wenn Sie nicht wollen, zusätzlich etwas zu tun, als nur DAOClass ruft Methode dann können Sie ModelClass mit DAOClass Klassen Karte, aber ich würde mit DAO nur für die Kommunikation mit empfehlen Ihr Persistenzsystem und Registerzuordnungen in Ihrer Hauptklasse und nicht im DAOClass-Konstruktor.

Answer 2

Ohne die Details zu verstehen, kann ich folgendes anbieten: Verwenden Sie eine Schnittstelle, um häufig benötigtes Verhalten zu definieren, und dann sollte eine allgemeine abstrakte Basisklasse zur Definition einer gemeinsamen Struktur berücksichtigt werden.