src.net.sf.beanlib.hibernate.HibernateBeanTransformer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of beanlib-hibernate Show documentation
Particularly handy when used with Hibernate. It allows developers to easily reuse the same pojo classes for both persistence instances and data transfer objects.
There is a newer version: 5.0.2beta
Show newest version
/*
 * Copyright 2005 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License")
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.sf.beanlib.hibernate;

import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.sql.Blob;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

import net.sf.beanlib.BeanPopulator;
import net.sf.beanlib.ProtectedSetterMethodCollector;
import net.sf.beanlib.api.BeanMethodCollector;
import net.sf.beanlib.api.BeanMethodFinder;
import net.sf.beanlib.api.BeanPopulatable;
import net.sf.beanlib.api.BeanSourceHandler;
import net.sf.beanlib.api.DetailedBeanPopulatable;
import net.sf.beanlib.utils.BlobUtils;
import net.sf.cglib.proxy.Enhancer;

import org.apache.commons.lang.ClassUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * Hibernate Bean Transformer.
 * 
 * @author Joe D. Velopar
 */
public abstract class HibernateBeanTransformer implements HibernateBeanTransformableSpi
{
	protected final Log log = LogFactory.getLog(this.getClass());
	
	// Contains those hibernate objects that have been replicated.
	private Map clonedMap = new IdentityHashMap();
	
	private DetailedBeanPopulatable detailedBeanPopulatable;
	private BeanPopulatable beanPopulatable; 
	private BeanSourceHandler beanSourceHandler;
	private BeanMethodFinder readerMethodFinder;
	private BeanMethodCollector setterMethodCollector = ProtectedSetterMethodCollector.inst;
	
	/** Custom Transformer. */
	private CustomHibernateBeanTransformable customTransformer = CustomHibernateBeanTransformable.NO_OP;

	private boolean debug;	
	
	public abstract void hibernateInitialize(Object obj);
	public abstract Blob hibernateCreateBlob(byte[] byteArray);
	
	public final void reset() {
		clonedMap = new IdentityHashMap();
	}
	
	public final  T transform(Object from, Class toClass) {
		try {
			if (customTransformer.isTransformable(from, toClass, this))
				return customTransformer.transform(from, toClass);
			return this.replicate(from, toClass);
		} catch (InstantiationException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (IllegalAccessException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (ClassNotFoundException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (SQLException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (IOException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (SecurityException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		} catch (NoSuchMethodException e) {
			log.error("", e);
			throw new BeanlibHibernateException(e);
		}
	}
	private Object replicate(Object from)
		throws SecurityException, InstantiationException, IllegalAccessException, ClassNotFoundException, 
		SQLException, IOException, NoSuchMethodException 
	{
		if (from == null)
			return null;
		return replicate(from, from.getClass());
	}
	/**
	 * Recursively replicate, if necessary, the given objects.
	 * Currently an object is replicated if it is an instance
	 * of Collection, Map, Timestamp, Date, Blob, Hibernate entity, 
	 * JavaBean, or an array.
	 * @throws NoSuchMethodException 
	 * @throws SecurityException 
	 */
	@SuppressWarnings("unchecked")
    private  T replicate(Object from, Class toClass) 
		throws InstantiationException, IllegalAccessException, ClassNotFoundException, 
		SQLException, IOException, SecurityException, NoSuchMethodException 
	{
		if (from == null)
			return null;
		if (toClass.isPrimitive())
			return (T)from;
		Class fromClass = from.getClass();
		// Collection
		if (from instanceof Collection) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			return (T)replicateCollection((Collection)from);
		}
		// Map
		if (from instanceof Map) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			return (T)replicateMap((Map)from);
		}
		// Timestamp
		if (from instanceof Timestamp) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			Timestamp ts = (Timestamp)from;
			return (T)new Timestamp(ts.getTime());
		}
		// Date
		if (from instanceof Date) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			Date date = (Date)from;
			return (T)new Date(date.getTime());
		}
		T to = (T)clonedMap.get(from);
		
		if (to != null) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			return to;	// already transformed.
		}
		// Array
		if (fromClass.isArray()) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			// both are arrays
			return (T)replicateArray(from);
		}
		String fromPackageName = ClassUtils.getPackageName(from.getClass());

		if (fromPackageName.startsWith("java.")) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			// Assume immutable object such as String, BigDecimal, etc.
			// TODO: is this assumption valid ?
			return (T)from;
		}
		if (fromPackageName.startsWith("net.sf.cglib.")) {
			// Want to skip the cglib stuff.
			return null;
		}
		// Blob
		if (from instanceof Blob) {
			if (!toClass.isAssignableFrom(fromClass))
				return null;
			Blob fromBlob = (Blob)from;
			to = (T)replicateBlob(fromBlob);
			clonedMap.put(from, to);
			return to;
		}
		// Assume non-array application classes.  TODO: is this assumption valid ?
		to = replicateApplicationObject(from, toClass);
		return to;
	}
    
    private  T replicateApplicationObject(Object from, Class toClass) 
        throws InstantiationException, IllegalAccessException, NoSuchMethodException 
    {
        T to = createToInstance(chooseClass(from.getClass(), toClass));
		clonedMap.put(from, to);
		// recursively populate member objects.
		populate(from, to);
        return to;
    }
    
	/** 
	 * Returns the fromClass if it is assignable to the toClass;  
	 * Otherwise returns the toClass. 
	 */
	@SuppressWarnings("unchecked")
    private  Class chooseClass(Class fromClass, Class toClass) {
		return (Class)(toClass.isAssignableFrom(fromClass) ? fromClass : toClass);
	}
    
    private Object replicateArray(Object from) 
		throws InstantiationException, IllegalAccessException, ClassNotFoundException, 
		SQLException, IOException, SecurityException, NoSuchMethodException 
	{
		Class fromClass = from.getClass();
		Class fromComponentType = fromClass.getComponentType();
		// primitive array
		if (fromComponentType.isPrimitive()) 
		{
			int len = Array.getLength(from);
			Object to = Array.newInstance(fromComponentType, len);
			System.arraycopy(from, 0, to, 0, len);
			clonedMap.put(from, to);
			return to;
		}
		// non-primitive array
		int len = Array.getLength(from);
		Object to = Array.newInstance(fromComponentType, len);
		clonedMap.put(from, to);
		Object[] fromArray = (Object[])from;
		Object[] toArray = (Object[])to;
		// recursively populate member objects.
		for (int i=fromArray.length-1; i >= 0; i--) {
			Object fromElement = fromArray[i];
			Object toElement = replicate(fromElement);
			toArray[i] = toElement;
		}
		return toArray;
	}

    // Thanks to Tammo van Lessen for reporting a bug related to cloning an empty collection:
    // http://sourceforge.net/tracker/index.php?func=detail&aid=1432471&group_id=140152&atid=745596
    private Collection replicateCollection(Collection from) 
		throws InstantiationException, IllegalAccessException, 
		ClassNotFoundException, SQLException, IOException, SecurityException, NoSuchMethodException 
	{
		Collection