How to log List interface method for existing code

Question

I have existing codebase that sometimes uses ArrayList or LinkedList and I need to find a way to log whenever add or remove is called to track what has been either added or removed.

What is the best way to make sure I have logging in place?

So for example.

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(123);

and

LinkedList<Integer> anotherNewList = new LinkedList<Integer>();
anotherNewList.add(333);

Not sure if I can intercept add method to achieve this or create overriding class that implements java.util.List interface then use it instead. Either way I'm looking for a good solution that requires minimum intervention and prefrerrably without using any third party packages...

Answer 1

I would use the so called Decorator Pattern to wrap your lists.

This would be a simple example code just to give you an idea:

private static class LogDecorator<T> implements Collection<T> {
    private final Collection<T> delegate;

    private LogDecorator(Collection<T> delegate) {this.delegate = delegate;}

    @Override
    public int size() {
      return delegate.size();
    }

    @Override
    public boolean isEmpty() {
      return delegate.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
      return delegate.contains(o);
    }

    @Override
    public Iterator<T> iterator() {
      return delegate.iterator();
    }

    @Override
    public Object[] toArray() {
      return delegate.toArray();
    }

    @Override
    public <T1> T1[] toArray(T1[] a) {
      return delegate.toArray(a);
    }

    @Override
    public boolean add(T t) {
      // ADD YOUR INTERCEPTING CODE HERE

      return delegate.add(t);
    }

    @Override
    public boolean remove(Object o) {
      return delegate.remove(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
      return delegate.containsAll(c);
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
      return delegate.addAll(c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
      return delegate.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
      return delegate.retainAll(c);
    }

    @Override
    public void clear() {
      delegate.clear();
    }
  }