WrapperHandler.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.wrap;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * Wraps Jsel object such as the underlying object becomes garbage collection
 * eligible and will be transparently restored from the database and source files
 * on demand
 * @author Pavel Vlasov
 * @version $Revision: 1.2 $
 */
public abstract class WrapperHandler implements InvocationHandler {
	private Object proxy;
	
	/**
	 * Subclasses can add more classes to wrap.
	 */
	protected Collection classesToWrap=new ArrayList();

	private static Map interfaceMap=new HashMap();
	
	public WrapperHandler(Object master) {
		proxy=Proxy.newProxyInstance(master.getClass().getClassLoader(), getClassInterfaces(master.getClass()), this);
		
		classesToWrap.add(Collection.class);
		classesToWrap.add(Map.class);
	}
	
	public Object getProxy() {
		return proxy;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {		
		Object[] unwrappedArgs;
		if (args!=null && args.length!=0) {
			unwrappedArgs=new Object[args.length];
			for (int i=0; i<unwrappedArgs.length; i++) {
				unwrappedArgs[i]=args[i];
				if (Proxy.isProxyClass(args[i].getClass())) {
					InvocationHandler handler=Proxy.getInvocationHandler(proxy);
					if (handler instanceof WrapperHandler) {
						unwrappedArgs[i]=((WrapperHandler) handler).getMaster();
						if (unwrappedArgs[i]==null) {
							throw new IllegalStateException("Unwrapped object is null for parameter "+i+" in method "+method);
						}
					}
				}
			}
		} else {
			unwrappedArgs=args;
		}
		
		Object master = getMaster();
		if (master==null) {
			throw new NullPointerException("Master object is null");
		}
		
		Object ret=method.invoke(master, unwrappedArgs);
		
		return wrap(ret, classesToWrap);
	}
	
	/**
	 * Convenience method.
	 * @param toWrap Object to wrap
	 * @param classesToWrap collection of classes that shall be wrapped. Wrappable is always wrapped. Can be null.
	 * @return Proxy object for toWrap if toWrap is either Wrappable or instance of one of classes from classesToWrap,
	 * toWrap otherwise
	 * @throws Throwable
	 */
	public static Object wrap(Object toWrap, Collection classesToWrap) throws Throwable {
		if (toWrap instanceof Wrappable) {
			return ((Wrappable) toWrap).getProxy();
		}
		
		if (classesToWrap!=null) {
			Iterator it=classesToWrap.iterator();
			while (it.hasNext()) {
				if (((Class) it.next()).isInstance(toWrap)) {
					return new StrongWrapperHandler(toWrap).getProxy();
				}
			}
		}
		
		return toWrap;
	}
	
	public static Object wrap(Object toWrap) throws Throwable {
		return wrap(toWrap, null);
	}

	protected abstract Object getMaster() throws Throwable;

	/**
	 * @param sourceClass
	 * @return all interfaces implemented by this class
	 */
	public static Class[] getClassInterfaces(Class sourceClass) {
		synchronized (interfaceMap) {
			Class[] ret=(Class[]) interfaceMap.get(sourceClass);
			if (ret==null) {
				Set set=new HashSet();
				getClassInterfaces(sourceClass, set);
				ret = (Class[]) new ArrayList(set).toArray(new Class[set.size()]);
				interfaceMap.put(sourceClass, ret);			
			}
			return ret;
		}
	}

	/**
	 * @param sourceClass
	 */
	private static void getClassInterfaces(Class sourceClass, Collection set) {
		if (sourceClass!=null) {
			Class[] interfaces = sourceClass.getInterfaces();
			for (int i=0; interfaces!=null && i<interfaces.length; i++) {
				getClassInterfaces(interfaces[i]);
			}
			getClassInterfaces(sourceClass.getSuperclass(), set);
			set.addAll(Arrays.asList(interfaces));
		}
	}
}