Implement Observable pattern like MutableLiveData in Android

Is your feature request related to a problem? Please describe. This feature suggestion aims to solve the problem of listening for variable value change (normally managed with JavaRX) without the need of importing the whole JavaRX system.

Describe the solution you’d like It would be great to have a decorator that provides Observable features.

Describe alternatives you’ve considered There are currently no elegant solutions available:

• Observable pattern: verbose and now deprecated in Java
• JavaRX: a-way-too-wide system to import only for such a small problem
• PropertyChangeSupport: it works but it’s too verbose and scattered, it would be glad to have a wrapper for it

Additional context Below a potential working solution (without the decorators):

package it.muzzialessandro.utils;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.UUID;

public class Observable<T> {

    private T value;
    private final PropertyChangeSupport pcSupport;
    private final String uuid;

    public Observable(T value) {
        this.value = value;
        this.pcSupport = new PropertyChangeSupport(this);
        this.uuid = UUID.randomUUID().toString();
        this.pcSupport.addPropertyChangeListener(evt -> {
                    synchronized (this) {
                        this.notify();
                    }
                });
    }

    //region Public Methods

    public void addPropertyChangeListener(PropertyChangeListener pcl) {
        this.pcSupport.addPropertyChangeListener(pcl);
    }

    public void removePropertyChangeListener(PropertyChangeListener pcl) {
        this.pcSupport.removePropertyChangeListener(pcl);
    }

    public void listenForChange() {
        synchronized (this) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //endregion

    //region Getter and Setter

    public T getValue() {
        return value;
    }

    public synchronized void setValue(T value) {
        this.pcSupport.firePropertyChange(this.uuid, this.value, value);
        this.value = value;
    }

    public String getUuid() {
        return this.uuid;
    }

    //endregion

}

Usage:

declaration:

Observable<String> strObs;

synchronous:

strObs.listenForChange();

asynchronous:

strObs.addPropertyChangeListener(evt -> doSomething());

[AleMuzzi]

I must have explained myself badly, my intention was to imitate the behavior of that Android class. I would really appreciate the lazy decorator, I’ve used lazy properties a couple of times in Kotlin. Honestly I didn’t understand the concept of “dynamic properties” but I will wait for news from you, count on me for the feedback 💪 If you prefer just send me a standard email instead of writing here, do as you prefer.

[AleMuzzi]

Yeah, great idea, keep me updated