ars.database.hibernate.Hibernates Maven / Gradle / Ivy

Go to download
package ars.database.hibernate;

import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.ArrayList;
import java.util.Map.Entry;
import java.util.Collection;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.net.URLDecoder;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

import org.hibernate.Session;
import org.hibernate.Hibernate;
import org.hibernate.SessionFactory;
import org.hibernate.type.Type;
import org.hibernate.type.CollectionType;
import org.hibernate.metadata.ClassMetadata;
import org.hibernate.engine.spi.SessionFactoryImplementor;

import ars.util.Beans;
import ars.util.Strings;
import ars.database.model.Model;
import ars.database.model.TreeModel;
import ars.database.repository.Query;
import ars.database.hibernate.DetachedCriteriaQuery;

/**
 * Hibernate操作工具类
 * 
 * @author yongqiangwu
 * 
 */
public final class Hibernates {
	private Hibernates() {

	}

	/**
	 * 获取数据模型元对象
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            数据模型
	 * @return 元对象
	 */
	public static ClassMetadata getClassMetadata(SessionFactory sessionFactory, Class model) {
		ClassMetadata metadata = sessionFactory.getClassMetadata(model);
		if (metadata == null) {
			throw new RuntimeException("Class metadata not found:" + model.getName());
		}
		return metadata;
	}

	/**
	 * 获取模型主键名称
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            模型对象
	 * @return 主键名称
	 */
	public static String getPrimary(SessionFactory sessionFactory, Class model) {
		return getClassMetadata(sessionFactory, model).getIdentifierPropertyName();
	}

	/**
	 * 获取主键类型
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            模型对象
	 * @return 主键类型
	 */
	public static Class getPrimaryClass(SessionFactory sessionFactory, Class model) {
		return getClassMetadata(sessionFactory, model).getIdentifierType().getReturnedClass();
	}

	/**
	 * 获取对象主键值
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param object
	 *            对象实例
	 * @return 主键值
	 */
	public static Serializable getIdentifier(SessionFactory sessionFactory, Object object) {
		return object == null ? null
				: object instanceof Model ? ((Model) object).getId()
						: (Serializable) Beans.getValue(object, getPrimary(sessionFactory, object.getClass()));
	}

	/**
	 * 设置对象主键值
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param object
	 *            对象实例
	 * @param id
	 *            主键值
	 */
	public static void setIdentifier(SessionFactory sessionFactory, Object object, Object id) {
		if (object != null && id != null) {
			if (object instanceof Model) {
				((Model) object).setId(Beans.toInteger(int.class, id));
			} else {
				Beans.setValue(object, getPrimary(sessionFactory, object.getClass()), id);
			}
		}
	}

	/**
	 * 获取模型属性
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            数据模型
	 * @return 属性名称数组
	 */
	public static String[] getProperties(SessionFactory sessionFactory, Class model) {
		return getClassMetadata(sessionFactory, model).getPropertyNames();
	}

	/**
	 * 获取类型对象
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param type
	 *            属性映射类型对象
	 * @return 类型对象
	 */
	public static Class getPropertyTypeClass(SessionFactory sessionFactory, Type type) {
		return type.isCollectionType()
				? ((CollectionType) type).getElementType((SessionFactoryImplementor) sessionFactory).getReturnedClass()
				: type.getReturnedClass();
	}

	/**
	 * 获取模型属性类型
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            数据模型
	 * @param property
	 *            属性名称
	 * @return 类型对象
	 */
	public static Type getPropertyType(SessionFactory sessionFactory, Class model, String property) {
		int index = property.indexOf('.');
		if (index > 0) {
			Type type = getPropertyType(sessionFactory, model, property.substring(0, index));
			return getPropertyType(sessionFactory, getPropertyTypeClass(sessionFactory, type),
					property.substring(index + 1));
		}
		ClassMetadata metadata = getClassMetadata(sessionFactory, model);
		if (metadata.hasIdentifierProperty() && metadata.getIdentifierPropertyName().equals(property)) {
			return metadata.getIdentifierType();
		}
		return metadata.getPropertyType(property);
	}

	/**
	 * 获取模型属性类型
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param model
	 *            数据模型
	 * @param property
	 *            属性名称
	 * @return 属性类型
	 */
	public static Class getPropertyClass(SessionFactory sessionFactory, Class model, String property) {
		Type type = getPropertyType(sessionFactory, model, property);
		return getPropertyTypeClass(sessionFactory, type);
	}

	/**
	 * 获取对象属性值
	 * 
	 * @param sessionFactory
	 *            会话工厂
	 * @param object
	 *            对象实例
	 * @param property
	 *            属性名称
	 * @return 属性值
	 */
	public static Object getValue(SessionFactory sessionFactory, Object object, String property) {
		if (object == null) {
			return null;
		}
		ClassMetadata metadata = getClassMetadata(sessionFactory, object.getClass());
		Object value = metadata.getPropertyValue(object, property);
		if (value != null && !Hibernate.isInitialized(value)) {
			Type type = metadata.getPropertyType(property);
			return type.isCollectionType() ? new ArrayList