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) {
            }
        }
    }