import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Interceptor;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.transaction.CMTTransactionFactory;
/**
* Hibernate 工具类 用于初始化Hibernate,并进行Session和Transaction的管理
*/
public class HibernateUtil {
private static Log log = LogFactory.getLog(HibernateUtil.class);
private static final String INTERCEPTOR_CLASS = "hibernate.util.interceptor_class";
private static Configuration configuration;
private static SessionFactory sessionFactory;
private static boolean useThreadLocal = true;
// 保存Session对象实例的线程局部变量
private static ThreadLocal threadSession = new ThreadLocal();
// 保存Transaction对象实例的线程局部变量
private static ThreadLocal threadTransaction = new ThreadLocal();
static {
try {
// 创建Configuration对象
configuration = new Configuration();
// 读取hibernate.properties或者hibernate.cfg.xml文件
configuration.configure();
// 指定一个全局的用户子定义的拦截器
String interceptorName = configuration
.getProperty(INTERCEPTOR_CLASS);
if (interceptorName != null) {
Class interceptorClass = HibernateUtil.class.getClassLoader()
.loadClass(interceptorName);
Interceptor interceptor = (Interceptor) interceptorClass
.newInstance();
configuration.setInterceptor(interceptor);
}
// 如果使用CMT,那么就不使用线程安全的Session和Transaction
if (CMTTransactionFactory.class
.getName()
.equals(
configuration
.getProperty(Environment.TRANSACTION_STRATEGY))) {
useThreadLocal = false;
}
if (configuration.getProperty(Environment.SESSION_FACTORY_NAME) != null) {
// 绑定Hibernate到JNDI
configuration.buildSessionFactory();
} else {
// 使用静态的变量
sessionFactory = configuration.buildSessionFactory();
}
} catch (Throwable ex) {
// 必须捕获Throwable,否则不能捕获NoClassDefFoundError异常以及它的子类错误
log.error("Building SessionFactory failed!", ex);
throw new ExceptionInInitializerError(ex);
}
}
/**
* 返回全局的SessionFactory对象的实例
*
* @return SessionFactory
*/
public static SessionFactory getSessionFactory() {
SessionFactory sf = null;
String sfName = configuration
.getProperty(Environment.SESSION_FACTORY_NAME);
if (sfName != null) {
log.debug("Looking up SessionFactory in JNDI.");
try {
sf = (SessionFactory) new InitialContext().lookup(sfName);
} catch (NamingException e) {
throw new RuntimeException(e);
}
} else {
sf = sessionFactory;
}
if (sf == null) {
throw new IllegalStateException("SessionFactory not available.");
}
return sf;
}
/**
* 重新构建SessionFactory对象的实例
*
*/
public static void rebuildSessionFactory() {
log.debug("Using current Configuration for rebuild");
rebuildSessionFactory(configuration);
}
/**
* 使用指定的Configuration对象重新构建SessionFactory对象的实例
*
* @param cfg
*/
public static void rebuildSessionFactory(Configuration cfg) {
log.debug("Rebuilding the SessionFactory from given Configuration.");
synchronized (sessionFactory) {
if (sessionFactory != null && !sessionFactory.isClosed()) {
sessionFactory.close();
}
if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null) {
cfg.buildSessionFactory();
} else {
sessionFactory = cfg.buildSessionFactory();
}
configuration = cfg;
}
}
/**
* 关闭当前SessionFactory并且释放所有资源
*
*/
public static void shutdown() {
log.debug("Shutting down Hibernate.");
// 关闭缓冲和连接池
getSessionFactory().close();
// 清除静态变量
configuration = null;
sessionFactory = null;
// 清除本地进程变量
threadSession.set(null);
threadTransaction.set(null);
}
/**
* 获得当前Session对象的实例
*
* @return Session
*/
public static Session getCurrentSession() {
if (useThreadLocal) {
Session s = (Session) threadSession.get();
if (s == null) {
log.debug("Opening new Session for this thread.");
s = getSessionFactory().openSession();
threadSession.set(s);
}
return s;
} else {
return getSessionFactory().getCurrentSession();
}
}
/**
* 重新连接当前的Session
*
* @param session
*/
public static void reconnect(Session session) {
if (useThreadLocal) {
log.debug("Reconnecting Session to this thrwad.");
session.reconnect();
threadSession.set(session);
} else {
log
.error("Using CMT/JTA,intercepted not supported reconnect call.");
}
}
/**
* 断开当前Session
*
* @return Session the disconnected Session
*/
public static Session disconnectedSession() {
if (useThreadLocal) {
Transaction tx = (Transaction) threadTransaction.get();
if (tx != null && (!tx.wasCommitted() || !tx.wasRolledBack())) {
throw new IllegalStateException(
"Disconnecting Session but Transaction still open.");
}
Session session = getCurrentSession();
threadSession.set(null);
if (session.isConnected() && session.isOpen()) {
log.debug("Disconnecting Session from this thread.");
session.disconnect();
}
return session;
} else {
log
.error("Using CMT/JTA,intercepted not supported disconnect call.");
return null;
}
}
/**
* 关闭Session对象
*
*/
public static void closeSession() {
if (useThreadLocal) {
Session s = (Session) threadSession.get();
threadSession.set(null);
Transaction tx = (Transaction) threadTransaction.get();
if (tx != null && (!tx.wasCommitted() || !tx.wasRolledBack())) {
throw new IllegalStateException(
"Closing Session but Transaction still open.");
}
if (s != null && s.isOpen()) {
log.debug("Closing Session of this thread.");
s.close();
}
} else {
log.warn("Using CMT/JTA,intercepted superfluous close call.");
}
}
/**
* 开始一个新的数据库事务
*
*/
public static void beginTransaction() {
if (useThreadLocal) {
Transaction tx = (Transaction) threadTransaction.get();
if (tx == null) {
log.debug("Starting new database transaction in this thread.");
tx= getCurrentSession().beginTransaction();
threadTransaction.set(tx);
}
} else {
log.warn("Using CMT/JTA,intercepted superfluous tx begin call.");
}
}
/**
* 提交数据库事务
*
*/
public static void commitTransaction() {
if (useThreadLocal) {
try {
Transaction tx = (Transaction) threadTransaction.get();
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
log
.debug("Committing database transaction of this thread.");
tx.commit();
}
threadTransaction.set(null);
} catch (RuntimeException e) {
log.error(e);
rollbackTransaction();
throw e;
}
} else {
log.warn("Using CMT/JTA,intercepted superfluous tx commit call.");
}
}
/**
* 回滚数据库事务
*
*/
public static void rollbackTransaction() {
if (useThreadLocal) {
Transaction tx = (Transaction) threadTransaction.get();
try {
threadTransaction.set(null);
if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
log
.debug("Trying to rollback database transaction of this thread.");
tx.rollback();
}
} catch (RuntimeException e) {
throw new RuntimeException(
"Migth swallow original cause,check Error log!", e);
} finally {
closeSession();
}
} else {
log.warn("Using CMT/JTA,intercepted superfluous tx rollback call.");
}
}
}
分享到:
相关推荐
Hibernate5.2.1 的工具类 创建session 和 sessionFactory
..\..........\....\HibernateUtil.java ..\..........\....\HttpResponseCacheFilter.java ..\..........\....\jdom ..\..........\....\....\DataFormatFilter.java ..\..........\....\....\...
│ │ HibernateUtil.java │ │ UsersDAO.java │ │ │ └─entity │ BillEntity.java │ GoodsListEntity.java │ └─WebRoot │ index.jsp │ ├─img │ dn1.jpg │ dn2.jpg │ dn3.jpg │...
HibernateUtil.java HibernateUtils.java HttpRequester.java HttpRespons.java HttpUtil.java MD5Util.java Pagination.java PropertiesUtil.java RegUtil.java StringUtil.java UploadUtil.java UUIDUtils.java
(2)dao 使用了公共的GenricDao接口及实现类GenricHibernateDao 并使用了泛型 com.chen.common 包中的CopyOfGenericHibernateDao.java HibernateUtil.java两个是在集成Spring前使用的 可以当做参考吧; (3) ...
《深入理解HibernateUtil:高效管理Hibernate Session与SessionFactory》 Hibernate,作为Java领域广泛使用的对象关系映射(ORM)框架,极大地简化了数据库操作。而HibernateUtil则是为了方便开发者管理Hibernate的...
每个具体类一个表 - 打开 HibernateUtil.java 并启用一个表每个 concreate 类注释类并运行 Application.java 这里创建了三个表。 每个层次类的一个表 - 打开 HibernateUtil.java 并启用每个层次类的一个表并运行 ...
在`HibernateUtil.java`这个文件中,我们可能会看到以下关键知识点: 1. **Hibernate配置**:文件可能包含了配置SessionFactory的代码,如定义配置文件路径、数据库连接参数等。 2. **SessionFactory的创建**:...
例如,在`HibernateUtil.java`类中,通过`newConfiguration().configure().buildSessionFactory();`初始化SessionFactory时,如果配置错误或资源未找到,将抛出异常。 5. **操作数据库**:在`Action`类中,可以通过...
<br>import java.util.List; import java.util.UUID; <br>import com.javaeedev.dao.UserDao; import com.javaeedev.domain.PasswordTicket; import com.javaeedev.domain.User; import ...
│ HibernateUtil.java │ JsonUtil.java │ list.txt │ log4j.properties │ messageResource_zh_CN.properties │ spring.xml │ struts.xml │ ├─28个java常用的工具类 │ │ Base64.java │ │ Base64...
- `hibernateUtil.java`:工具类,用于初始化SessionFactory并提供Session操作的方法。 - `测试类.java`:例如`TestHibernate.java`,包含CRUD操作的示例代码。 在测试类中,你会看到如何实例化SessionFactory,...
```java public class GenericHibernateDaoImpl<T> implements GenericDao<T> { private Class<T> clazz; @SuppressWarnings("unchecked") public GenericHibernateDaoImpl() { // 通过反射获取 T 的类型信息...
为以本机方式创建Hibernate的sessionFactory创建了新的HibernateUtil.java类表USERS也在这里创建和初始化 删除了JPA内容 persistence.xml 通过Resources.java设置EntityManager 创建了jboss-d
- HibernateUtil.java:包含SessionFactory的创建和关闭方法 - App.java:主程序,实现数据的CRUD操作 - pom.xml(如果有):Maven项目的配置文件,包含Hibernate和其他依赖的声明 以上就是"My First Hibernate APP...
`HibernateUtil.java`文件可能是Hibernate的工具类,通常包含SessionFactory的初始化、Session的获取和关闭,以及事务的管理等功能。通过这个文件,开发者可以了解如何在实际项目中集成和使用Hibernate。 综上所述...
Hibernate 是一个 Java 持久层框架,它主要为应用程序提供对象关系映射 (Object-Relational Mapping, ORM) 功能。通过 ORM,开发人员可以将 Java 对象直接映射到数据库表中,从而简化了数据访问层的开发工作。 ### ...
4. 实用工具类(如`HibernateUtil.java`):用于初始化SessionFactory,提供全局的SessionFactory实例。 通过这样的封装,我们可以大大减少DAO层的代码量,提高开发效率,同时保持代码的整洁和可维护性。这种设计...
- HibernateUtil.java:用于创建SessionFactory的工具类 - TestHibernate.java:包含JUnit测试用例的类 通过阅读和理解这些代码,你可以更好地了解Hibernate在实际应用中的工作原理。 总之,这个“hibernate入门小...