刚刚学习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) {
}
}
}