SoftCachingProxyFactory.java

Violations

Source code

package biz.hammurapi.cache;

import java.lang.ref.SoftReference;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import biz.hammurapi.convert.FilterInvocationHandler;
import biz.hammurapi.wrap.WrapperHandler;

/**
 * Creates proxy which caches return values of getXXX() method invocations
 * in soft references
 * @author Pavel
 *
 */
public class SoftCachingProxyFactory {

	private static final String GET = "get";

	/**
	 * Creates proxy which caches return values of getXXX() method
	 * invocations in soft references. Return values are keyed by
	 * method declaring type, method name, parameter types, and parameter
	 * values. Internal map is not cleaned up when SoftReference is cleared and
	 * entries do not have expiration time.
	 * Cache entries are invalidated when non-getXXX method is invoked
	 * and if that method is not declared by Object (i.e. hashCode() or
	 * equals() do not invalidate cache).
	 * The proxy prevent repeated invocations of the same method with same arguments
	 * from multiple threads. I.e. if one thread invoked a method and method invocation
	 * is in progress, other threads invoking same method with same parameters during
	 * method invocation will block and will receive the same return value.
	 * @return Caching proxy or master, if master doesn't implement any interfaces.
	 */
	public static Object createCachingProxy(final Object master) {
		if (master==null) {
			return null;
		}
		
		Class[] interfaces = WrapperHandler.getClassInterfaces(master.getClass());
		if (interfaces.length==0) {
			return master;
		}
		
		final Map getMap = new ConcurrentHashMap(); // List[declaring type, method name, param types, arg values -> Return value entry.

		
		FilterInvocationHandler ih = new FilterInvocationHandler() {

			public Object getMaster() {
				return master;
			}

			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				if (method.getDeclaringClass().getName().equals("java.lang.Object")) {
					return method.invoke(master, args);
				}
				
				if (!method.getName().startsWith(GET) || void.class.equals(method.getReturnType())) {
					getMap.clear();
					return method.invoke(master, args);
				}
				
				List invocationKey = new ArrayList();
				invocationKey.add(method.getDeclaringClass().getName());
				invocationKey.add(method.getName());
				Class[] pTypes = method.getParameterTypes();
				for (int i=0; pTypes!=null && i<pTypes.length; ++i) {
					invocationKey.add(pTypes[i].getName());
				}
				for (int i=0; args!=null && i<args.length; ++i) {
					invocationKey.add(args[i]);
				}
				
				ReturnValueEntry rve = (ReturnValueEntry) getMap.get(invocationKey);
				if (rve!=null) {
					return rve.get();
				}
				
				rve = new ReturnValueEntry();
				getMap.put(invocationKey, rve);
				
				try {
					Object ret = method.invoke(master, args);
					rve.set(ret);
					return ret;
				} catch (Throwable th) {
					rve.setProblem(th);
					throw th;
				}
			}
			
		};

		
		return Proxy.newProxyInstance(master.getClass().getClassLoader(), interfaces, ih);
	}
	
	private static class ReturnValueEntry {
		
		private boolean initialized;
		
		private SoftReference ref;
		
		private Throwable problem;
		
		/**
		 * Sets master object and notifies all threads waiting in get() method.
		 * @param obj
		 */
		synchronized void set(Object obj) {
			this.ref = new SoftReference(obj);
			initialized = true;
			notifyAll();
		}
		
		/**
		 * Sets master object and notifies all threads waiting in get() method.
		 * @param obj
		 */
		synchronized void setProblem(Throwable th) {
			problem = th;
			initialized = true;
			notifyAll();
		}
		
		/**
		 * Blocks until the master object is available
		 * @return master object.
		 */
		public synchronized Object get() throws Throwable {
			if (!initialized) {
				wait();
			}
			
			if (problem!=null) {
				throw problem;
			}
			
			return ref==null ? null : ref.get();
		}		
		
	}
	
}