Pattern di osservazione per tempi di osservazione imprevedibili

Question

Pattern di osservazione per tempi di osservazione imprevedibili

#1 da (4 voti)

1

Ho una situazione in cui gli oggetti vengono creati in momenti imprevedibili. Alcuni di questi oggetti sono creati prima di un evento importante, alcuni dopo. Se l'evento è già accaduto, faccio subito funzionare l'oggetto. Se l'evento è imminente, faccio in modo che l'oggetto osservi l'evento. Quando l'evento si attiva, l'oggetto viene notificato ed esegue lo stesso codice.

if (subject.eventAlreadyHappened()) {
    observer.executeStuff();
} else {
    subject.subscribe(observer);
}

Esiste un altro modello di design per avvolgere o addirittura sostituire questo schema di osservatore? Penso che sia un po 'sporco per me.

observer-pattern

posta JoJo 23.06.2012 - 07:27

fonte

1 risposta

Leggi altre domande sui tag observer-pattern

Come creare una rete semantica come wordnet basata su Wikipedia? Ruota, ridimensiona e trasforma nei videogiochi

score 4 · Accepted Answer

Un'alternativa sarebbe la seguente.

Gli osservatori vengono avvisati dell'evento attraverso il metodo

// Method on all observers.
void notify(Event event)

Tutti i nuovi oggetti sono iscritti alla notifica, quindi l'oggetto, invece di

if (subject.eventAlreadyHappened()) {
    observer.executeStuff();
} else {
    subject.subscribe(observer);
}

semplicemente

subject.subscribe(observer);

Quando si verifica l'evento, l'osservatore iscritto viene avvisato e l'evento viene memorizzato nella cache:

// Method on subject.
void handleEvent(Event event)
{
    // lastEvent is a member variable of subject.
    lastEvent = event;
    ...
    for (Observer observer : subscribedObservers())
    {
        observer.notify(event);
    }
}

Quando un nuovo oggetto è sottoscritto, viene notificato immediatamente se l'evento si è già verificato:

// Method on subject.
void subscribe(Observer observer)
{
    // Add observer to list.

    ...

    if (lastEvent != null)
    {
        observer.notify(lastEvent);
    }
}

Infine, l'osservatore ha un metodo di notifica:

// Method on observer.
void notify(Event event)
{
    executeStuff();
}

Quindi sostanzialmente la differenza è che il soggetto invia immediatamente una notifica a un oggetto appena sottoscritto se al momento della sottoscrizione l'evento si è già verificato.

Spero che questo aiuti.