Hibernate工具类，实现CURD操作

刚刚学习hibernate，对编写工具类做了一个初步的练习，简化对数据的操作

import java.lang.reflect.Field;
import java.util.List;


import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;


/**
 * hibernate工具类 实现CRUD操作
 * 
 * @author Johnson
 * @version 1.0
 */
public class HibernateUtil {
	private static Configuration configuration;
	private static SessionFactory sessionFactory;


	static {
		configuration = new Configuration();
		configuration.configure();
		sessionFactory = configuration.buildSessionFactory();
	}


	/**
	 * 
	 * @return SessionFactory
	 */
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}


	/**
	 * 获取线程绑定的Session
	 * 
	 * @return Session
	 */
	public static Session getSession() {
		return sessionFactory.getCurrentSession();
	}


	/**
	 * 关闭sessionFactory
	 */
	public static void closeSessionFactory() {
		sessionFactory.close();
	}


	/**
	 * 向数据库添加对象
	 * 
	 * @param <T>
	 * @param obj
	 *            添加数据库的实体类对象
	 * @return boolean
	 */
	public static <T> boolean add(T obj) {
		Transaction tx = null;
		Session session = null;
		boolean flag = false;
		try {
			session = getSession();
			tx = session.beginTransaction();
			session.save(obj);
			tx.commit();
			flag = true;
		} catch (Exception e) {
			tx.rollback();
			flag = false;
			e.printStackTrace();
		} finally {
			// session.close();
		}
		return flag;
	}


	/**
	 * 根据uid获取数据库中数据
	 * 
	 * @param <T>
	 * @param uid
	 *            对象uid
	 * @return User
	 */
	public static <T> T get(int uid, Class<T> cls) {
		Transaction tx = null;
		Session session = null;
		T obj = null;
		try {
			session = sessionFactory.openSession();
			tx = session.beginTransaction();
			obj = session.get(cls, uid);
			tx.commit();
		} catch (Exception e) {
			tx.rollback();
			e.printStackTrace();
		} finally {
			session.close();


		}
		return obj;
	}


	/**
	 * 根据uid更新数据库数据
	 * @param uid  对象uid
	 * @param newObj 新对象
	 * @param cls 对象class属性
	 * @return boolean
	 */
	public static <T> boolean update(int uid, T newObj, Class<T> cls) {
		Transaction tx = null;
		Session session = null;
		boolean flag = false;
		try {
			session = getSession();
			tx = session.beginTransaction();
			T obj = session.get(cls, uid);
			// 查询不到的情况
			if (obj == null) {
				return flag;
			}
			// 返回值的类型与注入类型不一样的情况
			if (!obj.getClass().equals(newObj.getClass())) {
				return flag;
			}
			HibernateUtil.mergeObject(newObj, obj);
			session.update(obj);
			tx.commit();
			flag = true;
		} catch (Exception e) {
			tx.rollback();
			flag = false;
			e.printStackTrace();
		} finally {
			// session.close();
		}
		return flag;
	}


	/**
	 * 根据uid删除数据库中对象
	 * 
	 * @param <T>
	 * @param uid
	 *            删除的对象uid
	 * @return boolean
	 */
	public static <T> boolean delete(int uid, Class<T> cls) {
		Transaction tx = null;
		Session session = null;
		boolean flag = false;
		try {
			session = getSession();
			tx = session.beginTransaction();
			T obj = session.get(cls, uid);
			if (obj == null) {
				return flag;
			}
			session.delete(obj);
			tx.commit();
			flag = true;
		} catch (Exception e) {
			tx.rollback();
			flag = false;
			e.printStackTrace();
		} finally {
			// session.close();
		}
		return flag;
	}
	/**
	 * 得到数据库中所有的T类型的数据
	 * @param cls T类型的class
	 * @return List<T>
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static <T> List getAll(Class<T> cls) {
		Transaction tx = null;
		Session session = null;
		List<T> list = null;
		try {
			session = sessionFactory.openSession();
			tx = session.beginTransaction();
			list = session.createQuery("from " + cls.getName()).list();
			tx.commit();
		} catch (Exception e) {
			tx.rollback();
			e.printStackTrace();
		} finally {
			session.close();
		}
		return list;
	}


}




	/**
	 * 将origin的所有属性注入destination
	 * @param origin 源对象
	 * @param destination 目标对象
	 * @return void
	 */
	public static <T> void mergeObject(T origin, T destination) {
		if (origin == null || destination == null)
			return;
		if (!origin.getClass().equals(destination.getClass()))
			return;


		Field[] fields = origin.getClass().getDeclaredFields();
		for (int i = 0; i < fields.length; i++) {
			try {
				fields[i].setAccessible(true);
				Object value = fields[i].get(origin);
				if (null != value) {
					fields[i].set(destination, value);
				}
				fields[i].setAccessible(false);
			} catch (Exception e) {
			}
		}
	}




不足之处，多多指教