Jak se vyhnout frustraci s Java eventy?

[hawran diskuse]

Jak dlouho zase bude trvat, než Vám dojde, že to je klasik, který na cokoli zareaguje "ale..." a přihodí dalších 100 důvodů, proč něco nejde?

[Reklama]

[Filip Jirsák]

bude fungovat jen od v 1.8, co když si budu chtít třeba na RPi

Java 8 na RPi běží, naopak je to první oficiální plnohodnotná verze pro ARM procesory.

Jinak myslím, že vás tady nikdo nenutil psát v Javě, tak nechápu, proč pořád musíte fňukat, že vám to opravdu nejde. Tak to nedělejte, je spousta jiných lidí, kteří na rozdíl od vás programovat umí…

[Lol Phirae]

[bsmk]

A co sa tak pozriet na https://github.com/ReactiveX/RxJava

[Zelenac]

Teď si hluboce urazil Filipa Jirsáka, který má Ask Toolbar ve svém prohlížeči vzorně nainstalován už řadu let.

[Reklama]

[Zelenac]

A co sa tak pozriet na https://github.com/ReactiveX/RxJava

Díky, mrknu, to už vypadá zajímavěji než co postoval tuším sten.

[perceptron]

na strane 6 sme sa dozvedeli ze to ma bezat na raspberry pi.

Vy jste mi tu dal řešení?

vasi kolegovia musia mat radost: bud vam vec naprogramuju alebo na nich otvorite stream nadavok :-)

ale kedze je s Vami sranda zasluzite si riesenie java 7.

Kód: [Vybrat]

package cz.root;

import java.util.Observable;
import java.util.Observer;

public class Counter {
    public static class CounterObservable extends Observable {
        private Counter counter;

        public CounterObservable(Counter counter) {
            if(counter == null) {
                throw new NullPointerException("Counter must be set");
            }
            this.counter = counter;
        }

        /**
         * Expose method as public to allow invocation
         * from delegatees.
         */
        @Override
        public synchronized void setChanged() {
            super.setChanged();
        }

        public Counter getCounter() {
            return counter;
        }
    }

    public static class CounterObserver implements Observer {
        public final void update(Observable o, Object arg) {
            if(o instanceof CounterObservable && arg instanceof Integer) {
                onUpdate(((CounterObservable) o).getCounter(), (Integer) arg);
            }
        }

        public void onUpdate(Counter counter, int newValue) {
            // no-op
        }
    }

    private CounterObservable observableDelegate = new CounterObservable(this);

    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int newValue) {
        if(this.value != newValue) {
            this.value = newValue;
            fireValueChanged(this.value);
        }
    }

    private void fireValueChanged(int newValue) {
        observableDelegate.setChanged();
        observableDelegate.notifyObservers(newValue);
    }

    public CounterObservable asObservable() {
        return this.observableDelegate;
    }

    public static void main(String[] args) {
        Counter a = new Counter();
        final Counter b = new Counter();

        a.asObservable().addObserver(new CounterObserver() {
            @Override
            public void onUpdate(Counter counter, int newValue) {
                b.setValue(newValue);
            }
        });

        a.setValue(12);
        System.out.printf("a = %d, b = %d\n", a.getValue(), b.getValue());

        b.setValue(48);
        System.out.printf("a = %d, b = %d\n", a.getValue(), b.getValue());
    }

}



třeba že chci, aby Java měla v stdlib podporu pro události - ANO TO OPRAVDU CHCI, vždyť je naprosto elementární věc

ok

*) riesenie observable v stdlib vam nevyhovuje lebo viacnasobna dedicnost
*) prisposobit si ho nechcete lebo chcete standardne riesenie
*) pisat vlastne veci nechcete.
*) cudzie veci pouzit nechcete.

toto je dead end. mozete tu dupkat nozickami po capslocku ze vam chyba podpora signalov / viacnasobna dedicnost ale takto to vo vyvoji daleko nedotiahnete.

[perceptron]

ked uz sme v reactive dimenziach tak spring riesenie. kontext sluzi ako event bus. counter publikuje eventy do kontextu, listenery ich vyberaju. mozete broadcoastovat, riesit asynchronne.

bezi aj na starom springu 2.5 z roku 2007. (v 4.2 je to este kratsie)

Kód: [Vybrat]

public class Counter {
    public static class ValueChangedEvent extends ApplicationEvent {
        public ValueChangedEvent(int newValue) {
            super(newValue);
        }
    }

    private ApplicationEventPublisher eventPublisher;

    private int value;

    public int getValue() {
        return value;
    }

    public void setValue(int newValue) {
        if(this.value != newValue) {
            this.value = newValue;
            fireValueChanged(this.value);
        }
    }

    private void fireValueChanged(int newValue) {
        if(eventPublisher != null) {
            eventPublisher.publishEvent(new ValueChangedEvent(newValue));
        }
    }

    public void setEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.refresh();

        Counter a = new Counter();
        a.setEventPublisher(context);

        Counter b = new Counter();

        context.addApplicationListener(new ApplicationListener() {
            @Override
            public void onApplicationEvent(ApplicationEvent e) {
                if(e instanceof ValueChangedEvent) {
                    b.setValue((Integer) ((ValueChangedEvent) e).getSource());
                }
            }
        });

        a.setValue(12);
        System.out.printf("a = %d, b = %d\n", a.getValue(), b.getValue());

        b.setValue(48);
        System.out.printf("a = %d, b = %d\n", a.getValue(), b.getValue());

    }
}


[ava]

A co sa tak pozriet na https://github.com/ReactiveX/RxJava

Díky, mrknu, to už vypadá zajímavěji než co postoval tuším sten.

Přesně tak, RxJava je dobrá cesta, divím se, že to tu tak zapadlo a tolik se vynalézá kolo

[Sten]

Vy jste mi tu dal řešení? To je řešení, které bude fungovat jen od v 1.8, co když si budu chtít třeba na RPi, nebo někam kde musí běžet starší verze Javy, portovat svoje knihovny?

RetroLambda

Druhá věc: vaše řešení neobsahuje elegantní způsob vyhnutí se ústavičné implementaci AddListerů, RemoveListenerů a dalších, protože to máte implementováno jen pro jednoho listenera.

Nemusíte. Podívejte se na to, jak to řeší mnou odkazovaný EventBus, je tam jedna metoda subscribe a jedna unsubscribe pro všechny typy eventů. Další možností je použít any listener interface:

Kód: [Vybrat]

public class ClassWithManyListeners
{
    // Předek všech listenerů
    public interface Listener
    {
        // Listenery pro událost onFoo
        public interface OnFoo
                extends Listener
        {
            public void onFoo(String foo);
        }

        // Listenery pro událost onBar
        public interface OnBar
                extends Listener
        {
            public boolean onBar(Object bar);
        }
    }

    // LinkedHashSet zaručuje pořadí při for-each. Pokud není potřeba, stačí jakýkoliv set
    private final Set<Listener.OnFoo> onFoos = new LinkedHashSet<>();
    private final Set<Listener.OnBar> onBars = new LinkedHashSet<>();

    public void subscribe(Listener listener)
    {
        if (listener instanceof Listener.OnFoo)
            onFoos.add((Listener.OnFoo)listener);
        if (listener instanceof Listener.OnBar)
            onBars.add((Listener.OnBar)listener);
    }

    public void unsibscribe(Listener listener)
    {
        onFoos.remove(listener);
        onBars.remove(listener);
    }

    public void methodThatTriggersFoo()
    {
        String foo = "whatever";
        for (Listeners.OnFoo f : onFoos)
            f.onFoo(foo);
    }

    public boolean methodThatTriggersBarAndChecksListeners()
    {
        Object bar = Boolean.TRUE;
        for (Listeners.OnBar b : onBars)
            if (!b.onBar(bar))
                return false;
        return true;
    }
}


jako třeba že chci, aby Java měla v stdlib podporu pro události - ANO TO OPRAVDU CHCI, vždyť je naprosto elementární věc.

Tak elementární, že abyste to měl v C++, potřebujete Qt s vlastním preprocesorem? (Ano, vím, že to jde i bez preprocesoru, ale v STL/ISO C++ žádné události stejně nejsou.)

[Zelenac]

A co tohle, je to me mistrovske dilo, ctete prosim pozorne:

Kód: [Vybrat]

public interface IObserver<T> {
public void eventFired(T delegat);
}

public class Observable<T> {

Collection<IObserver> observers = new ArrayList<>();

public void add(IObserver listener) {
observers.add(listener);
}

public void emit(T delegat) {
for(IObserver<T> observer : observers) {
observer.eventFired(delegat);
}
}

}

public class HruskaDelegat {
String barvaHrusky;
public HruskaDelegat(String barvaHrusky) {
this.barvaHrusky = barvaHrusky;
}
}

public class Strom {

public final Observable<HruskaDelegat> fireSpadlaHruska = new Observable<>();

public void zatresStromem() {
fireSpadlaHruska.emit(new HruskaDelegat("cervena"));
}
}


public class RegistrujeEventu {
public static void main(String[] args) {
Strom strom = new Strom();
strom.fireSpadlaHruska.add(new IObserver<HruskaDelegat>() {
@Override public void eventFired(HruskaDelegat delegat) {
System.out.println( delegat.barvaHrusky );
}
});

strom.zatresStromem();
}
}



[Zelenac]

Jo mám tam takovou chybku, už jsem si ji opravil nebudu to updatovat. Jde tu prostě o ten princip, totiž že vystavím atribut jako public a že to pak přímočaře užívám.

[Kit]

Jo mám tam takovou chybku, už jsem si ji opravil nebudu to updatovat. Jde tu prostě o ten princip, totiž že vystavím atribut jako public a že to pak přímočaře užívám.

Veřejné atributy nejsou horší než veřejné gettery a settery.

[perceptron]

A co tohle, je to me mistrovske dilo, ctete prosim pozorne:

to je skaredsi a horsi variant mojho riesenia.

* chcete videt zlatou prahu? pardon classcastexception?

            strom.fireSpadlaHruska.add(new IObserver<JabkoDelegat>() {
                @Override public void eventFired(JabkoDelegat delegat) {
                    System.out.println( delegat );
                }
            });

teda ste vobec nevyriesili problem s observable z java.util. (len si to myslite).

* dalej: verejne atributy v jave su "more than bad" practice. za to by vas aj v C# mlatili po prstoch
* prefixovat interfaces cez I je smrad z C#

[Kit]

* dalej: verejne atributy v jave su "more than bad" practice. za to by vas aj v C# mlatili po prstoch

Veřejné atributy se v C# používají naprosto běžně. Pouze se maskují za "vlastnosti".