[Java] Observer: meerdere notify's, bron achterhalen*

[Verwijderd]

Ik zit met een probleempje wat betreft het Observer pattern. Ik heb verscheidene methoden in een Observable die notifyObservers() aanroepen. Nu is mijn probleem het volgende: ik zou moeten kunnen achterhalen van uit welke methode die notify kwam, om zo in m'n update van m'n Observer navenant te kunnen reageren. Want niet alle updates zijn hetzelfde. Een situatieschets:

Java:

public class ProjectObservable extends Observable {
    // snippet

    public void insertProject(Project project) {
        this.projecten.add(project);
        projectMapper.addProject(project);
        
        setChanged();
        notifyObservers(project);
    }
    
    public void removeProject(Object project) {
        int index = this.projecten.indexOf(project);
        
        if (index >= 0) {
            projecten.remove(index);
            projectMapper.removeProject(((Project) project).getProjectId());
        
            setChanged();
            notifyObservers(project);
        }
    }
}

Het AbstractTableModel moet anders reageren bij een insert als bij een remove, dat lijkt me logisch.

Is er misschien een ander manier om zo'n probleem op te lossen? Het is eigenlijk meer een designprobleem bij het mvc pattern in Swing, ik weet nooit goed hoe ik dat moet oplossen.

Alvast bedankt.

// edit: fuck, titel verklooid, kan een moderator die ajb aanpassen naar "[Java] Observer: meerdere notify's, bron achterhalen"

[ Voor 4% gewijzigd door Verwijderd op 27-03-2008 11:28 ]

[LuCarD]

Wil je dat wel?

Begrijp me niet verkeerd, maar ik ben net bezig met het lezen over design patterns. En ik ben "nog" geen guru.

Maar volgens mij wil je niet aan je Observers vertellen wat er verandert is. Alleen dat er wat is verandert. De Observers halen dan zelf de relevante informatie op en verwerken die dan weer.
Want wat zou er gebeuren als je een ander soort update krijgt? Dan zou je weer langs alle observers moeten gaan en die weer gaan aanpassen om de nieuwe update te verwerken.

[Verwijderd]

Misschien wel, inderdaad.

Ik heb het nu opgelost door in update() te zeggen dat alle informatie in de JTable ververst moet worden met behulp van een fireTableDataChanged(). Ik weet niet in hoeverre dit een performante oplossing is. Het leek me namelijk beter om bij elke delete, insert, update te kijken wat er veranderd was en dezelfde wijzigingen dan door te voeren in de tabel.

[ Voor 3% gewijzigd door Verwijderd op 27-03-2008 12:02 ]

[bat266]

Ik denk dat Lucard een juiste verwoording geeft. Als de data (Observable) veranderd moet de Observer maar kijken wat ie met het gegeven data is veranderd doet. En een dataChanged event is inderdaad een van de oplossingen.

Over performace etc weet ik te weinig om iets nuttigs over te zeggen

[Woy]

in .NET heb je sinds de laatste versie een INotifyCollectionChanged ( En een implementatie in de vorm van ObservableCollection<T> ) interface die een dergelijk iets implementeerd.

Het komt eigenlijk neer op een gespecialiseerde versie van het Observer patroon voor Collections. ( In java wil je het waarschijnlijk wat anders implementeren, maar het idee is hetzelfde )

[ Voor 9% gewijzigd door Woy op 27-03-2008 12:59 ]

[Verwijderd]

Ik werk ook enkel in Java omdat het hogerop zo bepaald is. .NET is ook mijn platform naar keuze, maarja...

Nuja, wat mij betreft is mijn probleem "opgelost" en kan er gerust een slotje op deze thread. Iedereen hartelijk bedankt de hulp!

[Woy]

Een slotje is zowiezo niet nodig mischien dat iemand later nog wat aan dit topic heeft.

Verder haalt het natuurlijk niet zo uit of je in .NET of in Java werkt. Het idee kun je in beide talen makkelijk implementeren.

Mischien is het ook leuk om even te vertellen hoe je het "opgelost" hebt. Of bedoel je gewoon dat je er niks aan veranderd hebt?

[Verwijderd]

Zoals in mijn tweede post. In plaats van aparte acties voor update, insert, delete heb ik besloten om telkens volledig m'n JTable te verversen aan de hand van de datacollectie die wél up to date is.

Mijn eerste idee was dus om als er een actie uitgevoerd werd, de JTable zo aan te passen dat enkel die rij aangepast, toegevoegd of verwijderd wordt, zonder geheel de datacollectie weer uit te lezen. Maar aangezien het over kleine hoeveelheden data gaat, is zo'n omslachtige aanpak eigenlijk niet nodig.

Volgende keer dat ik een gelijkaardig probleem tegen kom, kijk ik wel eens om zelf een EventListener te schrijven. Momenteel heb ik maar een beperkt tijdsbestek, dus sla dat sla ik maar over.