关于hibernate 、ibatis、jdbctemplate对Bbasedao的封装已经使用方式

 

 

/********************************************************/

/*************Hibernate封装BaseDao(原生态)*************/

/********************************************************/

 

概要说明：

Hibernate封装BaseDao主要是通过调用HibernateUtil(这个类也是封装的)来实现基本的CURD操作;在HibernateUtil中，通过Configuration实例构建SessionFactory，SessionFactory用来创建Session实例，Configuration实例根据当前的配置信息，构造SessionFactory实例并返回。一旦SessionFactory构造完毕，即被赋予特定的配置信息。Session是持久层操作的基础，相当于JDBC的Connection。通过SessionFactory实例构建。Session实例提供的saveOrUpdate、delete和createQuery方法分别实现了数据库的插入更新、删除和查询操作，简化了数据库的基本操作

代码实例：

 

*  HibernateUtil：Hibernate工具类,Hibernate映射操作公用类 负责初始化、打开连接、获取连接、关闭连接等操作;

 

/*
*Hibernate工具类,Hibernate映射操作公用类
*负责初始化、打开连接、获取连接、关闭连接等操作
*/

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";//配置文件位置
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();//线程
    private static Configuration configuration = new Configuration();
    private static org.hibernate.SessionFactory sessionFactory;//会话工厂
    private static String configFile = CONFIG_FILE_LOCATION;

    static {
        try {
            configuration.configure(configFile);
            sessionFactory = configuration.buildSessionFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /***
     * 获得session
     *
     * @return
     * @throws HibernateException
     */
    public static Session getSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

        if (session == null || !session.isOpen()) {
            if (sessionFactory == null) {
                rebuildSessionFactory();
            }
            session = (sessionFactory != null) ? sessionFactory.openSession()
                    : null;
            threadLocal.set(session);
        }

        return session;
    }

    /*
    *重新创建SessionFactory
    */
    public static void rebuildSessionFactory() {
        try {
            configuration.configure(configFile);
            sessionFactory = configuration.buildSessionFactory();
        } catch (Exception e) {
            System.err.println("无法 在 baseDao 中 创建 SessionFactory ");
            e.printStackTrace();
        }
    }

    /*
    *获取当前session
    */
    public static Session currentSession() throws HibernateException {
        Session session = sessionFactory.openSession();
        return session;
    }

    /*
    *关闭session
    */
    public static void closeSession(Session session) {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);
        if (session != null) {
            session.close();
        }

    }

    /**
    * return session factory
    */
    public static org.hibernate.SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    /**
    * return session factory
    * <p/>
    * session factory will be rebuilded in the next call
    */
    public static void setConfigFile(String configFile) {
        HibernateUtil.configFile = configFile;
        sessionFactory = null;
    }

    /**
     * return hibernate configuration
     */
    public static Configuration getConfiguration() {
        return configuration;
    }
}

 

 

*HibernateBaseDao：调用Hibernate工具类HibernateUtil进行系列CURD操作;

/*
*调用Hibernate工具类HibernateUtil进行系列CURD操作
*/

import java.io.Serializable;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.juren.util.HibernateUtil;

public class HibernateBaseDao  {

    /**
     * 添加
     *
     * @param obj
     */
    public void add(Object obj) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();
            session.save(obj);
            tx.commit();

        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 删除
     *
     * @param obj
     */
    public void delete(Object obj) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();
            session.delete(obj);
            tx.commit();
        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 根据主键删除
     *
     * @param clazz
     * @param id
     */
    public void deleteById(Class clazz, Serializable id) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtil.getSession();
            session.delete(session.get(clazz, id));
            tx.commit();
        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 修改
     *
     * @param obj
     */
    public void update(Object obj) {
        Session session = null;
        Transaction tx = null;
        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();
            session.update(obj);
            tx.commit();
        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }

    }

    /**
     * 根据主键查询
     *
     * @param clazz
     * @param id
     * @return
     */
    public Object get(Class clazz, Serializable id) {
        Session session = null;

        try {
            session = HibernateUtil.getSession();
            Object obj = session.get(clazz, id);
            return obj;
        } finally {
            if (session != null) {
                session.close();
            }
        }

    }

    /**
     * 根据多个属性查询
     *
     * @param clazz
     * @param strs
     * @return
     */
    public Object getByNProperty(Class clazz, String... strs) {

        if (strs != null && strs.length != 0 && 0 != strs.length % 2) {
            StringBuffer hql = new StringBuffer("select model from "
                    + clazz.getName() + " as model where ");
            for (int i = 0; i < strs.length; i += 2) {
                hql.append(" " + strs[i] + " = " + strs[i + 1]);
            }

            Session session = null;
            try {
                session = HibernateUtil.getSession();
                List<Object> objs = session.createQuery(hql.toString()).list();
                if (objs != null && objs.size() != 0) {
                    return objs.get(0);
                } else {
                    return null;
                }
            } finally {
                if (session != null) {
                    session.close();
                }
            }
        } else {
            return null;
        }

    }

    /**
     * 根据HQL查询
     *
     * @param hql
     * @return
     */
    public Object getUniqueByHql(String hql) {

        Session session = null;

        try {
            session = HibernateUtil.getSession();
            List<Object> objs = session.createQuery(hql).list();
            if (objs != null && objs.size() != 0) {
                return objs.get(0);
            } else {
                return null;
            }

        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 根据SQL查询
     *
     * @param sql
     * @param clazz
     * @return
     */
    public Object getUniqueBySql(String sql, Class clazz) {

        Session session = null;

        try {
            session = HibernateUtil.getSession();
            Query query = session.createSQLQuery(sql).addEntity(clazz);
            List<Object> objs = query.list();
            if (objs != null && objs.size() != 0) {
                return objs.get(0);
            } else {
                return null;
            }
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 查询所有
     */
    public List<Object> getList(Class clazz) {
        Session session = null;

        try {
            session = HibernateUtil.getSession();
            String hql = "select model from " + clazz.getName() + " as model ";
            List list = session.createQuery(hql).list();
            return list;
        } finally {
            if (session != null) {
                session.close();
            }
        }

    }

    /**
     * 根据HQL查询 全部
     *
     * @param hql
     * @return
     */
    public List<Object> getListByHql(String hql) {

        Session session = null;

        try {
            session = HibernateUtil.getSession();
            List list = session.createQuery(hql).list();
            return list;

        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    /**
     * 根据SQL查询全部
     *
     * @param sql
     * @param clazz
     * @return
     */
    public List getListBySql(String sql, Class clazz) {

        Session session = null;

        try {
            session = HibernateUtil.getSession();
            Query query = session.createSQLQuery(sql).addEntity(clazz);
            return query.list();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

另外一种常见的封装是继承Spring的HibernateDaoSupport，也就是

org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

概要说明：

Spring为Hibernate 的整合提供了很好的支持，Spring的 DAO 支持类是:HiberanteDaoSupport; 继承HibernateDaoSupport类,使用HibernateTemplate来持久化，HibernateTemplate是Hibernate Session的轻量级封装; 该类只需要传入一个 SessionFactory 引用，即可得到一个HibernateTemplate实例，该实例功能非常强大，数据库的大部分操作也很容易实现。所有的 DAO类都继承HibernateDaoSupport，并实现相应的DAO 接口。而业务逻辑对象则面向接口编程，无须关心DAO 的实现细节。通过这种方式，可以让应用在不同的持久化技术之间切换;

代码实例：

* HibernateBaseDao：继承Spring的HibernateDaoSupport

 

import java.io.Serializable;
import java.util.List;
import org.hibernate.Query;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/*
* 继承Spring的HibernateDaoSupport
*/
public abstract class HibernateBaseDao extends HibernateDaoSupport {
    @SuppressWarnings("unchecked")
    public abstract Class getEntityClass();

    public abstract String getEntityType();

    //添加对象操作
    public void save(Serializable entity) {
        getHibernateTemplate().save(entity);
    }

    //修改对象操作
    public void update(Serializable entity) {
        getHibernateTemplate().update(entity);
    }

    //删除对象操作
    public void delete(int objId){
        getHibernateTemplate().delete(getHibernateTemplate().load(getEntityClass(), objId));
    }

    //查询对象列表
    @SuppressWarnings("unchecked")
    public List getAll(int count, int start) {
        String hql = "from " + getEntityType() + " m ";
        Query q = getHibernateTemplate().getSessionFactory()
                .openSession().createQuery(hql);
        q.setMaxResults(count);
        q.setFirstResult(start);
        return q.list();
    }
}

 

 

 

/********************************************************/

/***************Ibatis封装BaseDao(原生态)**************/

/********************************************************/

 

 

概要说明(个人测试)：

Ibatis封装BaseDao主要是通过调用IbatisUtil(这个类也是封装的)来实现基本的CURD操作;

 

关于IbatisUtil：SQLMap组件封装了iBATIS SQLMap相关SqlMapClient等内容，总共由两个接口、三个类组成。其中DaoTransaction接口、DaoTransactionManager接口和ConnectionDaoTransaction接口是通用接口，也是外部调用的API接口。SqlMapDao TransactionManager类实现DaoTransactionManager接口并关联iBATIS

SQLMap的SqlMapClient接口，同时它也依赖SqlMapDaoTransaction类。SqlMapDaoTransaction类实现ConnectionDaoTransaction接口（该接口继承DaoTransaction接口）并关联iBATIS SQLMap的SqlMapClient接口

 

SQLMap事务管理实现说明：

（1）初始化时，SqlMapDaoTransactionManager对象创建SqlMapClient对象。

（2）当调用SqlMapDaoTransactionManager对象的startTransaction方法时，该SqlMapClient对象为参数实例化一个SqlMapDaoTransaction对象，并调用SqlMapClient对象的startTransaction方法。

（3）当对SqlMapDaoTransactionManager对象进行commitTransaction、rollbackTransaction等业务操作，SqlMapDaoTransactionManager对象转移给SqlMapDaoTransaction对象的commit和rollback等方法。而SqlMapDaoTransaction对象也是最后转换给SqlMapClient对象的commitTransaction或endTransaction等方法进行处理的，完成处理后调用SqlMapClient对象的endTransaction方法，结束当前事务处理；

 

SQLMap事务处理的序列如图：

 

 

其实现步骤说明：

SqlMapDaoTransactionManager和SqlMapDaoTransaction

第1步骤：外部调用SqlMapDaoTransactionManager对象的configure方法，并把配置信息参数传递进来。

第1.1步骤：SqlMapDaoTransactionManager对象调用Resources的静态方法getUrlAsReader方法，获得Reader对象。

第1.2步骤：SqlMapDaoTransactionManager对象调用SqlMapClientBuilder对象的静态方法buildSqlMapClient，生成SqlMapClient对象。

 

第2步骤：外部调用SqlMapDaoTransactionManager对象的startTransaction方法。

       第2.1步骤：SqlMapDaoTransactionManager对象创建SqlMapDaoTransaction对象，并把参数SqlMapClient对象传递过去。

第2.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的startTransaction方法。

 

第3步骤：外部调用SqlMapDaoTransactionManager对象的commitTransaction方法。

第3.1步骤：SqlMapDaoTransactionManager对象调用SqlMapDaoTransaction对象的commit方法。

第3.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的commitTransaction方法。

第3.1.2步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的endTransaction方法，关闭SQLMap的当前事务。

 

第4步骤：外部调用SqlMapDaoTransactionManager对象的commitTransaction方法。

第4.1步骤：SqlMapDaoTransactionManager对象调用SqlMapDaoTransaction对象的commit方法。

第4.1.1步骤：SqlMapDaoTransaction对象调用SqlMapClient对象的endTransaction方法，关闭SQLMap的当前事务。

 

 

代码实例：

* IbatisUtil :Ibatis工具类,Ibatis操作公用类、负责初始化SqlMapClient操作

 

 

import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;

/*
*Ibatis工具类,Ibatis操作公用类
*负责初始化SqlMapClient操作
*/
public class IbatisUtil {
    // 首先初始化iBatis获得一个SqlMapClient对象
    private static String CONFIG_FILE_LOCATION = "/SqlMapConfig.xml";
    private static SqlMapClient sqlMap = null;
    private static String configFile = CONFIG_FILE_LOCATION;

    static {
        try {
        java.io.Reader reader = com.ibatis.common.resources.Resources
            .getResourceAsReader(configFile);
        sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
    } catch (Exception e) {
        e.printStackTrace();
    }
    }

    //获取SqlMapClient
    public static SqlMapClient getSqlMap(){
        return sqlMap;
    }
}

 

* IbatisBaseDao:调用Ibatis工具类IbatisUtil进行系列CURD操作

 

/*
*调用Ibatis工具类IbatisUtil进行系列CURD操作
*/

import java.sql.SQLException;
import java.util.List;

import com.ibatis.sqlmap.client.SqlMapClient;

public class IbatisBaseDao {

     /**
     * 添加对象操作
     * @param obj 对象实例 sqlMapId SqlMap配置文件中所对应的id
     * 备注：修改对象操作与之类似
     */
    public void save(Object obj,String sqlMapId) {
        SqlMapClient sqlMap = IbatisUtil.getSqlMap();
        try {
            sqlMap.startTransaction();

            sqlMap.update(sqlMapId, obj);
            sqlMap.commitTransaction();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                sqlMap.endTransaction();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /*
     * 删除对象操作
     * @param objId sqlMapId SqlMap配置文件中所对应的id
     * 备注：objId可以为String类型，根据不同的数据库设计决定传参类型
     */
    public void delete(Integer objId,String sqlMapId) {
        SqlMapClient sqlMap = IbatisUtil.getSqlMap();
        try {
            sqlMap.startTransaction();
            sqlMap.update(sqlMapId, objId);
            sqlMap.commitTransaction();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                sqlMap.endTransaction();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /*
     * 获取对象List列表（包含分页）
     * @param start 分页参数 sqlMapId SqlMap配置文件中所对应的id
     * 备注：不同数据库支持sql分页的语句可能不一样
     */
    @SuppressWarnings("unchecked")
    public List<Object> getAll(int start,String sqlMapId) {
        SqlMapClient sqlMap = IbatisUtil.getSqlMap();
        List<Object> res =  new ArrayList();
        try {
            sqlMap.startTransaction();
            res = sqlMap.queryForList(sqlMapId, start);
            sqlMap.commitTransaction();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                sqlMap.endTransaction();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return res;
    }
}

 

另外一种常见的封装是继承Spring的SqlMapClientDaoSupport，也就是

org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

 

代码实例：

* IbatisBaseDao：继承Spring的SqlMapClientDaoSupport

 

import java.io.Serializable;
import java.sql.SQLException;
import java.util.List;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

/**
 * IBatis Dao的泛型基类.
 * 继承于Spring的SqlMapClientDaoSupport
 */
@SuppressWarnings("unchecked")
public class IBatisBaseDao1 extends SqlMapClientDaoSupport {

     public static final String POSTFIX_INSERT = ".insert";
     public static final String POSTFIX_UPDATE = ".update";
     public static final String POSTFIX_DELETE = ".delete";
     public static final String POSTFIX_DELETE_PRIAMARYKEY = ".deleteByPrimaryKey";
     public static final String POSTFIX_SELECT = ".select";

     /**
     * 根据ID获取对象
     *
     * @throws BaseException
     * @throws SQLException
     */
     public <T> T get(Class<T> entityClass, Serializable id) throws SQLException {
       T o = (T) getSqlMapClient().queryForObject(entityClass.getName() + POSTFIX_SELECT, id);
       return o;
     }

    /**
     * 新增对象
     *
     * @throws SQLException
     */
     public void insert(Object o) throws SQLException {
         getSqlMapClient().insert(o.getClass().getName() + POSTFIX_INSERT, o);
     }

     /**
     * 保存对象
     *
     * @throws SQLException
     */
     public int update(Object o) throws SQLException {
         return getSqlMapClient().update(o.getClass().getName() + POSTFIX_UPDATE, o);
     }

     /**
     * 删除对象
     *
     * @throws SQLException
     */
     public int remove(Object o) throws SQLException {
         return getSqlMapClient().delete(o.getClass().getName() + POSTFIX_DELETE, o);
     }

     /**
     * 根据ID删除对象
     *
     * @throws SQLException
     */
     public <T> int removeById(Class<T> entityClass, Serializable id) throws SQLException {
         return getSqlMapClient().delete(entityClass.getName() + POSTFIX_DELETE_PRIAMARYKEY, id);
     }

     /**
     * 获取全部对象
     * @throws SQLException
     */
     public <T> List<T> getAll(Class<T> entityClass) throws SQLException {
         return getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);
     }
}

 

/********************************************************/

/*****************jdbctemplate封装BaseDao****************/

/********************************************************/

第一：概要说明：

1，Spring JDBC抽象框架所带来的价值将在以下几个方面得以体现：（注：使用了Spring JDBC抽象框架之后，应用开发人员只需要完成斜体字部分的编码工作。）

       指定数据库连接参数

       打开数据库连接

       声明SQL语句

       预编译并执行SQL语句

       遍历查询结果（如果需要的话）

       处理每一次遍历操作

       处理抛出的任何异常

       处理事务

       关闭数据库连接

Spring将替我们完成所有单调乏味的JDBC底层细节处理工作

 

2，Spring JDBC包结构

       Spring JDBC抽象框架由四个包构成：core、 dataSource、object以及support。

 

       org.springframework.jdbc.core包由JdbcTemplate类以及相关的回调接口（callback interface）和类组成。

 

       org.springframework.jdbc.datasource包由一些用来简化DataSource访问的工具类，以及各种DataSource接口的简单实现(主要用于单元测试以及在J2EE容器之外使用JDBC)组成。工具类提供了一些静态方法，诸如通过JNDI获取数据连接以及在必要的情况下关闭这些连接。它支持绑定线程的连接，比如被用于DataSourceTransactionManager的连接。

 

       接下来，org.springframework.jdbc.object包由封装了查询、更新以及存储过程的类组成，这些类的对象都是线程安全并且可重复使用的。它们类似于JDO，与JDO的不同之处在于查询结果与数据库是“断开连接”的。它们是在org.springframework.jdbc.core包的基础上对JDBC更高层次的抽象。

 

       最后，org.springframework.jdbc.support包提供了一些SQLException的转换类以及相关的工具类。

 

       在JDBC处理过程中抛出的异常将被转换成org.springframework.dao包中定义的异常。因此使用Spring JDBC进行开发将不需要处理JDBC或者特定的RDBMS才会抛出的异常。所有的异常都是unchecked exception，这样我们就可以对传递到调用者的异常进行有选择的捕获。

 

3，JDBC核心类实现JDBC的基本操作和错误处理

可参考：JDBC核心类实现JDBC的基本操作和错误处理

 

4，注意事项：

1) jdbcTemplate有很多的ORM化回调操作将返回结果转为对象列表，但很多时候还是需要返回ResultSet，Spring有提供一个类似ResultSet的 Spring SqlRowSet对象。

 

2) 注意jdbcTemplate尽量只执行查询操作，莫要进行更新，否则很容易破坏Hibernate的二级缓存体系。