Хороший способ иметь Слушателя Коллекции?

Question

Есть ли лучший способ иметь слушателя в java-коллекции, чем заключать его в класс, реализующий шаблон наблюдателя?

Answer 1

Вы должны проверить Застекленные списки

Он содержит наблюдаемые классы List, которые запускают события при добавлении, удалении, замене и т. Д. Элементов

Answer 2

Вы можете использовать ForwardingSet , ForwardingList и т. Д. Из Guava , чтобы украсить конкретный экземпляр нужным поведением.

Вот моя собственная реализация, которая просто использует простые API JDK:

// create an abstract class that implements this interface with blank implementations
// that way, annonymous subclasses can observe only the events they care about
public interface CollectionObserver<E> {

    public void beforeAdd(E o);

    public void afterAdd(E o);

    // other events to be observed ...

}

// this method would go in a utility class
public static <E> Collection<E> observedCollection(
    final Collection<E> collection, final CollectionObserver<E> observer) {
        return new Collection<E>() {
            public boolean add(final E o) {
                observer.beforeAdd(o);
                boolean result = collection.add(o);
                observer.afterAdd(o);
                return result;
            }

            // ... generate rest of delegate methods in Eclipse

    };
    }

Answer 3

События Apache .

"Commons-Events предоставляет дополнительные классы для запуска и обработки событий. Он сосредоточен на Java Collections Framework, предоставляя декораторы для других коллекций, которые запускают события."

Answer 4

Что ж, если вам не нужен экземпляр java.util.Collection или List, вы можете использовать DefaultListModel . Мне не известны какие-либо "настоящие" реализации Collection с поддержкой встроенного слушателя / наблюдателя.

Answer 5

Есть много способов достичь этого - часто я использую этот подход

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ObservableArrayList<E> extends ArrayList<E> {

    private @interface MethodId {
         private static final int REMOVE = 2;
         private static final int ADD = 1;
    }

    public interface ListObserver<E> {
        void onElementAdded(E element);
        void onElementRemoved(E element);
    }

    public ObservableArrayList(int capacity) {
        super(capacity);
        ensureObserver();
    }

    public ObservableArrayList() {
        ensureObserver();
    }

    public ObservableArrayList(Collection<? extends E> collection) {
        super(collection);
        ensureObserver();
    }

    private List<WeakReference<ListObserver<E>>> _listObserverWeakRefList;

    public void addObserver(ListObserver<E> observer) {
         _listObserverWeakRefList.add(new WeakReference<ListObserver<E>>   (observer));
    }

    private void ensureObserver() {
       if (_listObserverWeakRefList == null) {
            _listObserverWeakRefList = new ArrayList<>();
       }
    }

    @Override
    public boolean add(E object) {
        super.add(object);
        callObservable(MethodId.ADD, object);
        return true;
    }

    @Override
    public boolean remove(Object object) {
        boolean removed = super.remove(object);
        if (removed) callObservable(MethodId.REMOVE, object);
        return removed;
    }

    private void callObservable(@MethodId int methodId, Object element) {
         for (WeakReference<ListObserver<E>> observerRef :  _listObserverWeakRefList) {
             ListObserver<E> observer = observerRef.get();
             if (observer != null) {
                 switch (methodId) {
                    case MethodId.ADD:
                        observer.onElementAdded((E) element);
                        break;
                    case MethodId.REMOVE:
                        observer.onElementRemoved((E) element);
                        break;
                } 
            }
        }
    }

}