HibernateConnectionProvider.java 这是对hibernate 底层的封装

原创 2007年09月21日 15:32:00

感谢好朋友小智的帮助

/*
 * 文件名: HibernateConnectionProvider.java
 *
 * 创建日期: 2007-4-2
 *
 * Copyright(C) 2007, by xiaozhi.
 *
 * 原始作者: <a href="mailto:xiaozhi19820323@hotmail.com">xiaozhi</a>
 *
 */
package com.ultrapower.impl;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.SessionFactoryImpl;

import com.ultrapower.IEntityDAO;
import com.ultrapower.utils.ConnectionProvider;
import com.ultrapower.utils.support.Page;
import com.ultrapower.utils.support.SearchCondition;

/**
 * 负责为单个Entity 提供CRUD操作的Hibernate DAO基类和与QUARTZ的结合。
 *
 * @author <a href="mailto:xiaozhi19820323@hotmail.com">xiaozhi</a>
 *
 * @version $Revision$
 *
 * @since 2007-4-2
 */
public class HibernateConnectionProvider implements ConnectionProvider,IEntityDAO
{

 /**数据库连接*/
 private Connection conn = null ;
 
 /**SessionFactory接口的实现类的对象*/
 private static SessionFactoryImpl sessionFactory = null;

 /**日志对象*/
 private static final Log logger = LogFactory.getLog(HibernateConnectionProvider.class);
 
 /**定义Session局部线程*/
 private  ThreadLocal localSession = new ThreadLocal();
 
 /**定义事物局部线程*/
 private  ThreadLocal localTransaction = new ThreadLocal();
 
 /**定义SessionFactory*/
 protected  static SessionFactory factory = null;
 
 /**
  * 初始化SessionFactory
  *
  */
  private static synchronized void init()
  {
   if (factory != null)
   {
             return;
      }

      try
      {
          factory = new Configuration().configure().buildSessionFactory();
         
          sessionFactory = (SessionFactoryImpl)factory ;
       }
      catch (HibernateException he)
      {
             logger.info("SessionFactory init lost " + he);
            
             he.printStackTrace() ;
      }
  }
 
  /**
   * 从局部线程里得到Session
   *
   * @return
   */
  public Session getSession()
  {
   Session session = (Session)localSession.get() ;
  
   if(session == null)
   {
    session = this.openSession() ;
   }
   else if(!session.isOpen())
   {
    throw new RuntimeException("Session is close");
   }
  
   return session ;
  }
 
  /**
   * 通过SessionFactory创建Session
   *
   * @return
   */
  private Session openSession()
  {
   if(factory == null)
   {
    this.init() ;
   }
  
   if(factory == null)
   {
    throw new RuntimeException("SessionFactory nullity");
   }
  
   Session session = null ;
  
   try
   {
             session = factory.openSession();

             localSession.set(session);

      }
   catch (HibernateException he)
   {
             if (logger.isInfoEnabled())
             {
                 logger.info("session init lost");
             }
            
             he.printStackTrace() ;
      }
  
   return session ;
  }
 
  /**
   * 检查Session是否为空
   *
   */
  protected void validateSession()
  {
   if(this.getSession() == null)
   {
    throw new RuntimeException("there is no session");
   }
  }
 
  /**
   * 检查对象是否为空
   *
   * @param obj 对象
   */
  protected void validateObject(Object obj)
  {
   if(obj == null)
   {
    throw new RuntimeException("Object is not null");
   }
  }
 
  /**
   * 开启事物
   *
   */
  private void beginTransaction()
  {
   Session session = this.getSession() ;
  
   this.validateSession() ;
   try
   {
    Transaction tx = session.beginTransaction() ;
   
    localTransaction.set(tx);
   
    logger.info("Tranaaction is begin") ;
   }
   catch(HibernateException he)
   {
    logger.info("Tranaaction is not begin") ;
   
    throw new RuntimeException("Tranaaction is not begin");
   }
  }
 
  /**
   * 提交事物或者回滚
   *
   * @param commit 是否提交
   */
  private void endTransaction(boolean commit)
  {
   Transaction tx = (Transaction)this.localTransaction.get() ;
  
   if(tx == null)
   {
    throw new RuntimeException("Transaction is not begin") ;
   }
  
   if(commit)
   {
    tx.commit() ;
   }
   else
   {
    tx.rollback() ;
   }
  }
 
  /**
   * 得到实体的Criteria
   *
   * @param clazz
   *            类对象
   * @return Criteria对象
   */
  protected Criteria getEntityCriteria(Class clazz)
  {
   return this.getSession().createCriteria(clazz) ;
  }
 
 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.utils.ConnectionProvider#getConnection()
  */
 public Connection getConnection() throws SQLException
 {
  if(sessionFactory == null)
  {
   this.init() ;
  }
  
  conn = sessionFactory.getConnectionProvider().getConnection() ;
  
  return conn;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.utils.ConnectionProvider#shutdown()
  */
 public void shutdown() throws SQLException
 {
  if(sessionFactory != null)
  {
   sessionFactory.close() ;
  }
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#begin()
  */
 public void begin()
 {
  this.beginTransaction() ;
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#commit()
  */
 public void commit()
 {
  this.endTransaction(true) ;
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#findBy(org.quartz.utils.support.SearchCondition, java.lang.Class)
  */
 public List findBy(SearchCondition searchCond, Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  criteria.add(Restrictions.eq(searchCond.getField(), searchCond.getFieldValue())) ;
  
  criteria.addOrder(Order.desc(this.getIdName(clazz))) ;
  
  return criteria.list() ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#findBy(org.quartz.utils.support.SearchCondition, org.quartz.utils.support.Page, java.lang.Class)
  */
 public List findBy(SearchCondition searchCond, Page page, Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  criteria.add(Restrictions.eq(searchCond.getField(), searchCond.getFieldValue())) ;
  
  if(page.getOrderBy() != null)
  {
   if(page.getOrder().equals("asc"))
   {
    criteria.addOrder(Order.asc(page.getOrderBy())) ;
   }
   else
   {
    criteria.addOrder(Order.desc(page.getOrderBy())) ;
   }
  }
  else
  {
   criteria.addOrder(Order.desc(this.getIdName(clazz))) ;
  }
  
  criteria.setFirstResult(page.getFirstItemPos()) ;
  
  criteria.setMaxResults(page.getPageSize()) ;
  
  return criteria.list() ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#findBy(org.quartz.utils.support.SearchCondition, int, java.lang.Class)
  */
 public Page findBy(SearchCondition searchCond, int pageSize, Class clazz)
 {
  StringBuffer hqlStr = new StringBuffer() ;
  
  hqlStr.append("select count(*) from "+clazz.getName()) ;
  
  hqlStr.append(" obj where obj."+searchCond.getField()) ;
  
  hqlStr.append("=:fieldValue") ;
  
  Query query = this.getSession().createQuery(hqlStr.toString()) ;
  
  query.setParameter("fieldValue", searchCond.getFieldValue()) ;
  
  List list = query.list() ;
  
  long totalCount = ((Long)list.get(0)).longValue();
  
  hqlStr.delete(0, hqlStr.length()) ;
  
  hqlStr = null ;
  
  if(totalCount < 1)
  {
   totalCount = 0 ;
  }
  
  return new Page(totalCount,pageSize);
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#findByNotLike(org.quartz.utils.support.SearchCondition, java.lang.Class)
  */
 public List findByNotLike(SearchCondition searchCond, Class clazz)
 {
  
  return this.getEntityCriteria(clazz).add(Restrictions.ne(searchCond.getField(), searchCond.getFieldValue())).list();
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#flush()
  */
 public void flush()
 {
  this.getSession().flush() ;
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#get(java.lang.Class, java.io.Serializable)
  */
 public Object get(Class clazz, Serializable id)
 {
  
  return this.getSession().load(clazz, id);
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#getAll()
  */
 public List getAll(Class clazz)
 {
  return this.getSession().createCriteria(clazz).addOrder(Order.desc(this.getIdName(clazz))).list() ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#getAll(org.quartz.utils.support.Page, java.lang.Class)
  */
 public List getAll(Page page, Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  if(page.getOrderBy() != null)
  {
   if(page.getOrder().equals("asc"))
   {
    criteria.addOrder(Order.asc(page.getOrderBy())) ;
   }
   else
   {
    criteria.addOrder(Order.desc(page.getOrderBy())) ;
   }
  }
  else
  {
   criteria.addOrder(Order.desc(this.getIdName(clazz))) ;
  }
  
  criteria.setFirstResult(page.getFirstItemPos()) ;
  
  criteria.setMaxResults(page.getPageSize()) ;
  
  return criteria.list() ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#getAll(int, java.lang.Class)
  */
 public Page getAll(int pageSize, Class clazz)
 {
  
  String hqlStr = "select count(*) from "+clazz.getName() ;
  
  Query query = this.getSession().createQuery(hqlStr) ;
  
  List list = query.list() ;
  
  long totalCount = ((Long)list.get(0)).longValue() ;
  
  if(totalCount < 1)
  {
   totalCount = 0 ;
  }
  
  return new Page(totalCount,pageSize);
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#refresh(java.lang.Object, org.hibernate.LockMode)
  */
 public void refresh(Object object, LockMode mode)
 {
  this.getSession().refresh(object, mode) ;
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#release()
  */
 public void release()
 {
  if(this.localSession.get() != null)
  {
   
   Session session = (Session)this.localSession.get() ;
   
   try
   {
    if(session.isOpen())
    {
     session.close() ;
     System.out.println("--------------------------------------------------------") ;
     System.out.println("session is close!!") ;
    }
   }
   catch(HibernateException e)
   {
    session.close() ;
    
    e.printStackTrace() ;
   }
   finally
   {
    this.localSession.set(null) ;
    
    this.localTransaction.set(null) ;
   }
  }
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#remove(java.lang.Object)
  */
 public void remove(Object o)
 {
  try
  {
   //this.begin() ;
   
   this.getSession().delete(o) ;
   
   //this.commit() ;
  }
  catch(HibernateException e)
  {
   //this.rollback() ;
   
   logger.info("remove object is lost") ;
   
   e.printStackTrace() ;
  }
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#removeById(java.io.Serializable, java.lang.Class)
  */
 public void removeById(Serializable id, Class clazz)
 {
  try
  {
   //this.begin() ;
   
   this.getSession().delete(this.get(clazz, id)) ;
   
   //this.commit() ;
  }
  catch(HibernateException e)
  {
   //this.rollback() ;
   
   logger.info("by id remove is lost") ;
   
   e.printStackTrace() ;
  }
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#rollback()
  */
 public void rollback()
 {
  this.endTransaction(false) ;
  
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#saveOrUpdate(java.lang.Object)
  */
 public void saveOrUpdate(Object o)
 {
  try
  {
   //this.begin() ;
   
   this.getSession().saveOrUpdate(o) ;
   
   //this.commit() ;
  }
  catch(HibernateException e)
  {
   //this.rollback() ;
   
   logger.info("save object is lost") ;
   
   e.printStackTrace() ;
  }
 }
 
 /**
  * 增加一条记录
  * @param o
  * @return void
  */
 public void save(Object o)
 {
  try
  {
   //this.begin() ;
   
   this.getSession().save(o) ;
   
   //this.commit() ;
  }
  catch(HibernateException e)
  {
   //this.rollback() ;
   
   logger.info("save object is lost") ;
   
   e.printStackTrace() ;
  }
 }
 
 /**
  * 更新一条记录
  * @param o
  * @return void
  */
 public void update(Object o)
 {
  try
  {
   //this.begin() ;
   
   this.getSession().update(o) ;
   
   //this.commit() ;
  }
  catch(HibernateException e)
  {
   //this.rollback() ;
   
   logger.info("update object is lost") ;
   
   e.printStackTrace() ;
  }
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#createCriteria(org.hibernate.criterion.Criterion[], java.lang.Class)
  */
 public Criteria createCriteria(Criterion[] criterion,Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  for(int i = 0 ; i < criterion.length ; i++)
  {
   criteria.add(criterion[i]) ;
  }
  
  return criteria ;
 }


 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#getIdName(java.lang.Class)
  */
 public String getIdName(Class clazz)
 {
  if(factory == null)
  {
   this.init() ;
  }
  
  String idName = factory.getClassMetadata(clazz).getIdentifierPropertyName() ;
  
  return idName ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#finByLike(org.quartz.utils.support.SearchCondition, java.lang.Class)
  */
 public List finByLike(SearchCondition searchCond, Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  criteria.add(Restrictions.like(searchCond.getField(), "%"+searchCond.getFieldValue()+"%",MatchMode.ANYWHERE)) ;
  
  return criteria.list() ;
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#finByLike(org.quartz.utils.support.SearchCondition, org.quartz.utils.support.Page, java.lang.Class)
  */
 public List finByLike(SearchCondition searchCond, Page page, Class clazz)
 {
  Criteria criteria = this.getEntityCriteria(clazz) ;
  
  criteria.add(Restrictions.like(searchCond.getField(), "%"+searchCond.getFieldValue()+"%",MatchMode.ANYWHERE)) ;
  
  if(page.getOrderBy() != null)
  {
   if(page.getOrder().equals("asc"))
   {
    criteria.addOrder(Order.asc(page.getOrderBy())) ;
   }
   else
   {
    criteria.addOrder(Order.desc(page.getOrderBy())) ;
   }
  }
  else
  {
   criteria.addOrder(Order.desc(this.getIdName(clazz))) ;
  }
  
  criteria.setFirstResult(page.getFirstItemPos()) ;
  
  criteria.setMaxResults(page.getPageSize()) ;
  
  return criteria.list();
 }

 /*
  *
  * (non-Javadoc)
  *
  * @see org.quartz.IEntityDAO#finByLike(org.quartz.utils.support.SearchCondition, int, java.lang.Class)
  */
 public Page finByLike(SearchCondition searchCond, int pageSize, Class clazz)
 {
  StringBuffer hqlStr = new StringBuffer() ;
  
  hqlStr.append("select count(*) from "+clazz.getName()) ;
  
  hqlStr.append(" obj where obj.") ;
  
  hqlStr.append(searchCond.getField()) ;
  
  hqlStr.append(" like:fieldValue") ;
  
  Query query = this.getSession().createQuery(hqlStr.toString()) ;
  
  query.setParameter("fieldValue", searchCond.getFieldValue()) ;
  
  List list = query.list() ;
  
  long totalCount = ((Long)list.get(0)).longValue() ;
  
  if(totalCount < 1)
  {
   totalCount = 0 ;
  }
  
  hqlStr.delete(0, hqlStr.length()) ;
  
  hqlStr = null ;
  
  
  return new Page(totalCount,pageSize);
 }


}
 

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

这是我看过最好的对hibernate的二级缓存解析

很多人对二级缓存都不太了解,或者是有错误的认识,我一直想写一篇文章介绍一下hibernate的二级缓存的,今天终于忍不住了。  我的经验主要来自hibernate2.1版本,基本原理和3.0、3.1...

这是一个结合了Struts、Spring、Hibernate的登录完整

这是一个结合了Struts、Spring、Hibernate的登录完整项目,所用数据库为MySQL。其中Spring负责全局管理,Hibernate负责数据库查询操作,Struts负责逻辑处理。步骤如...

Hibernate底层技术简介 CGLIB

  • 2010-01-07 17:04
  • 150KB
  • 下载

Hibernate底层技术简介 CGLIB

  • 2008-03-07 11:14
  • 150KB
  • 下载

各种猥琐的Java笔试/面试题目的答案(这是我自己测试得出的答案,如有不对的欢迎批评指正)

1、运算符优先级问题,下面代码的结果是多少?(笔试) public class Test {       public static void main(String[]&#...

这是Hibernate API文档

  • 2008-12-20 21:31
  • 3.72MB
  • 下载

这是一个秒杀系统,即大量用户抢有限的商品,先到先得 用户并发访问流量非常大,需要分布式的机器集群处理请求 系统实现使用Java

1、用户请求分发模块:使用Nginx或Apache将用户的请求分发到不同的机器上。 2、用户请求预处理模块:判断商品是不是还有剩余来决定是不是要处理该请求。 3、用户请求处理模块:把通过预处理的请...

这是我在四天内听完陈老师讲的java基础加强后的总结

在这几天的学习中,谁然感觉很累,但是总算没有白忙,终于有了一点收获,希望在今后的学习中不断地进步。

模拟Hibernate底层生成SQL语句(反射机制)

package com.factory.dao.imp; import java.lang.reflect.Field; import java.lang.reflect.InvocationTar...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)