'Observer is deprecated in Java 9. What should we use instead of it?

Java 9 came out, and Observer has been deprecated. Why is that? Does it mean that we shouldn't implement observer pattern anymore?

It would be good to know what is a better alternative?

javajava-8deprecatedobserver-patternjava-9


Solution 1:[1]

There are more reasons :

Not Serializable - Since, Observable doesn't implements Serializable. So, you can't Serialize Observable neither its subclass.

No Thread Safety - The methods can be overridden by its subclasses, and event notification can occur in different orders and possibly on different threads, which is enough to disrupt any "thread safety".

Less to offer -

They don't provide a rich enough event model for applications. For example, they support only the notion that something has changed, but they don't convey any information about what has changed

Open Issues - As mentioned, there were lot of major issues raised (thread safety, Serializable) and most of them had complexities to fix and still "not fixed" or No Active Development, and that is the reason why it has been deprecated.

I would also recommend to read this answer Why should the observer pattern be deprecated?, @Jeff has explained other reasons for deprecation.

So, what's the alternative we have ?

You can use PropertyChangeEvent and PropertyChangeListener from java.beans package.

Solution 2:[2]

Why Observer is deprecated in Java 9?

Ans: The Observable class and the Observer interface have been deprecated in Java 9 because the event model supported by Observer and Observable is quite limited, the order of notifications delivered by Observable is unspecified, and state changes are not in one-for-one correspondence with notifications.

See Java doc https://docs.oracle.com/javase/9/docs/api/java/util/Observable.html

Alternate of Observer pattern?

There are many alternatives of Observer design pattern and Reactive Streams is one of them.

Reactive Streams or Flow API:

Flow is a class introduced in Java 9 and has 4 interrelated interfaces : Processor, Publisher, Subscriber and Subscription.

Flow.Processor : A component that acts as both a Subscriber and Publisher.

Flow.Publisher : A producer of items received by Subscribers.

Flow.Subscriber : A receiver of messages.

Flow.Subscription: Message control linking a Flow.Publisher and Flow.Subscriber.

See Java doc https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/Flow.html

Solution 3:[3]

Considering that the Observable class and the Observer interface have been deprecated as of Java 9. As per the post Java's Observer and Observable Are Deprecated in JDK 9

The event model supported by Observer and Observable is quite limited, the order of notifications delivered by Observable is unspecified, and state changes are not in one-for-one correspondence with notifications. For a richer event model, consider using the java.beans package. For reliable and ordered messaging among threads, consider using one of the concurrent data structures in the java.util.concurrent package. For reactive streams style programming, see the Flow API.

Solution 4:[4]

Also is possible to use CDi 2.0 , Event Handling

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 Michael
Solution 2 Mohit Tyagi
Solution 3
Solution 4 KronosOne

Related Questions