SyncronizingProxyFactory: Pattern or antipattern?
I'm creating several interfaces (which actually may be remote). The
implementations need to perform several operations "atomically" on one
target object.
I thought that it might be annoying to write stuff like:
synchronized(target) { target.doOp(); target.doOp2(); }
over and over again. So I thought to borrow a concept from Aspect
Oriented Programming, and wrote myself a proxy factory.
If my interfaces extend java.rmi.Remote, does this preclude me from
using this Proxy class?
<sscce>
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
/**
*/
public class SynchronizingProxyFactory {
private static class SynchronizedInvocationHandler<E> implements
InvocationHandler {
private final E target;
private final Object sync;
public SynchronizedInvocationHandler(E target, Object sync) {
this.target = target;
this.sync = sync;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable{
synchronized(sync) {
try {
return method.invoke(target, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
}
}
public static <E> E synchronizedProxy(Class<E> iface, E target,
Object sync) {
return (E)Proxy.newProxyInstance(iface.getClassLoader(),
new Class[]{iface}, new
SynchronizedInvocationHandler<E>(target, sync)) ;
}
}
</sscce>
Thanks,
Daniel.