`

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

hibernateibatisjdbc 
阅读更多
 

 

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

/*************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映射操作公用类 负责初始化、打开连接、获取连接、关闭连接等操作;


 

[java] view plaincopyprint?
 
  1. /* 
  2. *Hibernate工具类,Hibernate映射操作公用类 
  3. *负责初始化、打开连接、获取连接、关闭连接等操作 
  4. */  
  5.   
  6. import org.hibernate.HibernateException;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.cfg.Configuration;  
  9.   
  10. public class HibernateUtil {  
  11.     private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";//配置文件位置   
  12.     private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();//线程   
  13.     private static Configuration configuration = new Configuration();  
  14.     private static org.hibernate.SessionFactory sessionFactory;//会话工厂  
  15.     private static String configFile = CONFIG_FILE_LOCATION;  
  16.   
  17.     static {  
  18.         try {  
  19.             configuration.configure(configFile);  
  20.             sessionFactory = configuration.buildSessionFactory();  
  21.         } catch (Exception e) {  
  22.             e.printStackTrace();  
  23.         }  
  24.     }  
  25.   
  26.     /*** 
  27.      * 获得session 
  28.      *  
  29.      * @return 
  30.      * @throws HibernateException 
  31.      */  
  32.     public static Session getSession() throws HibernateException {  
  33.         Session session = (Session) threadLocal.get();  
  34.   
  35.         if (session == null || !session.isOpen()) {  
  36.             if (sessionFactory == null) {  
  37.                 rebuildSessionFactory();  
  38.             }  
  39.             session = (sessionFactory != null) ? sessionFactory.openSession()  
  40.                     : null;  
  41.             threadLocal.set(session);  
  42.         }  
  43.   
  44.         return session;  
  45.     }  
  46.   
  47.     /* 
  48.     *重新创建SessionFactory 
  49.     */  
  50.     public static void rebuildSessionFactory() {  
  51.         try {  
  52.             configuration.configure(configFile);  
  53.             sessionFactory = configuration.buildSessionFactory();  
  54.         } catch (Exception e) {  
  55.             System.err.println("无法 在 baseDao 中 创建 SessionFactory ");  
  56.             e.printStackTrace();  
  57.         }  
  58.     }  
  59.   
  60.     /* 
  61.     *获取当前session 
  62.     */  
  63.     public static Session currentSession() throws HibernateException {  
  64.         Session session = sessionFactory.openSession();  
  65.         return session;  
  66.     }  
  67.   
  68.     /* 
  69.     *关闭session 
  70.     */  
  71.     public static void closeSession(Session session) {  
  72.         Session session = (Session) threadLocal.get();  
  73.         threadLocal.set(null);  
  74.         if (session != null) {  
  75.             session.close();  
  76.         }  
  77.   
  78.     }   
  79.   
  80.     /** 
  81.     * return session factory 
  82.     */  
  83.     public static org.hibernate.SessionFactory getSessionFactory() {  
  84.         return sessionFactory;  
  85.     }  
  86.   
  87.     /** 
  88.     * return session factory 
  89.     * <p/> 
  90.     * session factory will be rebuilded in the next call 
  91.     */  
  92.     public static void setConfigFile(String configFile) {  
  93.         HibernateUtil.configFile = configFile;  
  94.         sessionFactory = null;  
  95.     }  
  96.   
  97.     /** 
  98.      * return hibernate configuration 
  99.      */  
  100.     public static Configuration getConfiguration() {  
  101.         return configuration;  
  102.     }  
  103. }  

 

 

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

[java] view plaincopyprint?
 
  1. /* 
  2. *调用Hibernate工具类HibernateUtil进行系列CURD操作 
  3. */  
  4.   
  5. import java.io.Serializable;  
  6. import java.util.List;  
  7.   
  8. import org.hibernate.Query;  
  9. import org.hibernate.Session;  
  10. import org.hibernate.Transaction;  
  11. import com.juren.util.HibernateUtil;  
  12.   
  13. public class HibernateBaseDao  {  
  14.   
  15.     /** 
  16.      * 添加 
  17.      * 
  18.      * @param obj 
  19.      */  
  20.     public void add(Object obj) {  
  21.         Session session = null;  
  22.         Transaction tx = null;  
  23.         try {  
  24.             session = HibernateUtil.getSession();  
  25.             tx = session.beginTransaction();  
  26.             session.save(obj);  
  27.             tx.commit();  
  28.   
  29.         } catch (Exception e) {  
  30.             if (tx != null) {  
  31.                 tx.rollback();  
  32.             }  
  33.         } finally {  
  34.             if (session != null) {  
  35.                 session.close();  
  36.             }  
  37.         }  
  38.     }  
  39.   
  40.     /** 
  41.      * 删除 
  42.      * 
  43.      * @param obj 
  44.      */  
  45.     public void delete(Object obj) {  
  46.         Session session = null;  
  47.         Transaction tx = null;  
  48.         try {  
  49.             session = HibernateUtil.getSession();  
  50.             tx = session.beginTransaction();  
  51.             session.delete(obj);  
  52.             tx.commit();  
  53.         } catch (Exception e) {  
  54.             if (tx != null) {  
  55.                 tx.rollback();  
  56.             }  
  57.         } finally {  
  58.             if (session != null) {  
  59.                 session.close();  
  60.             }  
  61.         }  
  62.     }  
  63.   
  64.     /** 
  65.      * 根据主键删除 
  66.      * 
  67.      * @param clazz 
  68.      * @param id 
  69.      */  
  70.     public void deleteById(Class clazz, Serializable id) {  
  71.         Session session = null;  
  72.         Transaction tx = null;  
  73.         try {  
  74.             session = HibernateUtil.getSession();  
  75.             session.delete(session.get(clazz, id));  
  76.             tx.commit();  
  77.         } catch (Exception e) {  
  78.             if (tx != null) {  
  79.                 tx.rollback();  
  80.             }  
  81.         } finally {  
  82.             if (session != null) {  
  83.                 session.close();  
  84.             }  
  85.         }  
  86.     }  
  87.   
  88.     /** 
  89.      * 修改 
  90.      * 
  91.      * @param obj 
  92.      */  
  93.     public void update(Object obj) {  
  94.         Session session = null;  
  95.         Transaction tx = null;  
  96.         try {  
  97.             session = HibernateUtil.getSession();  
  98.             tx = session.beginTransaction();  
  99.             session.update(obj);  
  100.             tx.commit();  
  101.         } catch (Exception e) {  
  102.             if (tx != null) {  
  103.                 tx.rollback();  
  104.             }  
  105.         } finally {  
  106.             if (session != null) {  
  107.                 session.close();  
  108.             }  
  109.         }  
  110.   
  111.     }  
  112.   
  113.     /** 
  114.      * 根据主键查询 
  115.      * 
  116.      * @param clazz 
  117.      * @param id 
  118.      * @return 
  119.      */  
  120.     public Object get(Class clazz, Serializable id) {  
  121.         Session session = null;  
  122.   
  123.         try {  
  124.             session = HibernateUtil.getSession();  
  125.             Object obj = session.get(clazz, id);  
  126.             return obj;  
  127.         } finally {  
  128.             if (session != null) {  
  129.                 session.close();  
  130.             }  
  131.         }  
  132.   
  133.     }  
  134.   
  135.     /** 
  136.      * 根据多个属性查询 
  137.      * 
  138.      * @param clazz 
  139.      * @param strs 
  140.      * @return 
  141.      */  
  142.     public Object getByNProperty(Class clazz, String... strs) {  
  143.   
  144.         if (strs != null && strs.length != 0 && 0 != strs.length % 2) {  
  145.             StringBuffer hql = new StringBuffer("select model from "  
  146.                     + clazz.getName() + " as model where ");  
  147.             for (int i = 0; i < strs.length; i += 2) {  
  148.                 hql.append(" " + strs[i] + " = " + strs[i + 1]);  
  149.             }  
  150.   
  151.             Session session = null;  
  152.             try {  
  153.                 session = HibernateUtil.getSession();  
  154.                 List<Object> objs = session.createQuery(hql.toString()).list();  
  155.                 if (objs != null && objs.size() != 0) {  
  156.                     return objs.get(0);  
  157.                 } else {  
  158.                     return null;  
  159.                 }  
  160.             } finally {  
  161.                 if (session != null) {  
  162.                     session.close();  
  163.                 }  
  164.             }  
  165.         } else {  
  166.             return null;  
  167.         }  
  168.   
  169.     }  
  170.   
  171.     /** 
  172.      * 根据HQL查询 
  173.      * 
  174.      * @param hql 
  175.      * @return 
  176.      */  
  177.     public Object getUniqueByHql(String hql) {  
  178.   
  179.         Session session = null;  
  180.   
  181.         try {  
  182.             session = HibernateUtil.getSession();  
  183.             List<Object> objs = session.createQuery(hql).list();  
  184.             if (objs != null && objs.size() != 0) {  
  185.                 return objs.get(0);  
  186.             } else {  
  187.                 return null;  
  188.             }  
  189.   
  190.         } finally {  
  191.             if (session != null) {  
  192.                 session.close();  
  193.             }  
  194.         }  
  195.     }  
  196.   
  197.     /** 
  198.      * 根据SQL查询 
  199.      * 
  200.      * @param sql 
  201.      * @param clazz 
  202.      * @return 
  203.      */  
  204.     public Object getUniqueBySql(String sql, Class clazz) {  
  205.   
  206.         Session session = null;  
  207.   
  208.         try {  
  209.             session = HibernateUtil.getSession();  
  210.             Query query = session.createSQLQuery(sql).addEntity(clazz);  
  211.             List<Object> objs = query.list();  
  212.             if (objs != null && objs.size() != 0) {  
  213.                 return objs.get(0);  
  214.             } else {  
  215.                 return null;  
  216.             }  
  217.         } finally {  
  218.             if (session != null) {  
  219.                 session.close();  
  220.             }  
  221.         }  
  222.     }  
  223.   
  224.     /** 
  225.      * 查询所有 
  226.      */  
  227.     public List<Object> getList(Class clazz) {  
  228.         Session session = null;  
  229.   
  230.         try {  
  231.             session = HibernateUtil.getSession();  
  232.             String hql = "select model from " + clazz.getName() + " as model ";  
  233.             List list = session.createQuery(hql).list();  
  234.             return list;  
  235.         } finally {  
  236.             if (session != null) {  
  237.                 session.close();  
  238.             }  
  239.         }  
  240.   
  241.     }  
  242.   
  243.     /** 
  244.      * 根据HQL查询 全部 
  245.      * 
  246.      * @param hql 
  247.      * @return 
  248.      */  
  249.     public List<Object> getListByHql(String hql) {  
  250.   
  251.         Session session = null;  
  252.   
  253.         try {  
  254.             session = HibernateUtil.getSession();  
  255.             List list = session.createQuery(hql).list();  
  256.             return list;  
  257.   
  258.         } finally {  
  259.             if (session != null) {  
  260.                 session.close();  
  261.             }  
  262.         }  
  263.     }  
  264.   
  265.     /** 
  266.      * 根据SQL查询全部 
  267.      * 
  268.      * @param sql 
  269.      * @param clazz 
  270.      * @return 
  271.      */  
  272.     public List getListBySql(String sql, Class clazz) {  
  273.   
  274.         Session session = null;  
  275.   
  276.         try {  
  277.             session = HibernateUtil.getSession();  
  278.             Query query = session.createSQLQuery(sql).addEntity(clazz);  
  279.             return query.list();  
  280.         } finally {  
  281.             if (session != null) {  
  282.                 session.close();  
  283.             }  
  284.         }  
  285.     }  
  286. }  

另外一种常见的封装是继承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

 

[java] view plaincopyprint?
 
  1. import java.io.Serializable;  
  2. import java.util.List;  
  3. import org.hibernate.Query;  
  4. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
  5.   
  6. /* 
  7. * 继承Spring的HibernateDaoSupport 
  8. */  
  9. public abstract class HibernateBaseDao extends HibernateDaoSupport {  
  10.     @SuppressWarnings("unchecked")  
  11.     public abstract Class getEntityClass();  
  12.   
  13.     public abstract String getEntityType();  
  14.   
  15.     //添加对象操作  
  16.     public void save(Serializable entity) {  
  17.         getHibernateTemplate().save(entity);  
  18.     }  
  19.   
  20.     //修改对象操作  
  21.     public void update(Serializable entity) {  
  22.         getHibernateTemplate().update(entity);  
  23.     }  
  24.   
  25.     //删除对象操作  
  26.     public void delete(int objId){  
  27.         getHibernateTemplate().delete(getHibernateTemplate().load(getEntityClass(), objId));  
  28.     }  
  29.   
  30.     //查询对象列表  
  31.     @SuppressWarnings("unchecked")  
  32.     public List getAll(int count, int start) {  
  33.         String hql = "from " + getEntityType() + " m ";  
  34.         Query q = getHibernateTemplate().getSessionFactory()  
  35.                 .openSession().createQuery(hql);  
  36.         q.setMaxResults(count);  
  37.         q.setFirstResult(start);  
  38.         return q.list();  
  39.     }  
  40. }  

 

 

 

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

/***************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操作

 

 

[java] view plaincopyprint?
 
  1. import com.ibatis.sqlmap.client.SqlMapClient;  
  2. import com.ibatis.sqlmap.client.SqlMapClientBuilder;  
  3.   
  4. /* 
  5. *Ibatis工具类,Ibatis操作公用类 
  6. *负责初始化SqlMapClient操作 
  7. */  
  8. public class IbatisUtil {             
  9.     // 首先初始化iBatis获得一个SqlMapClient对象   
  10.     private static String CONFIG_FILE_LOCATION = "/SqlMapConfig.xml";  
  11.     private static SqlMapClient sqlMap = null;  
  12.     private static String configFile = CONFIG_FILE_LOCATION;  
  13.   
  14.     static {  
  15.         try {  
  16.         java.io.Reader reader = com.ibatis.common.resources.Resources  
  17.             .getResourceAsReader(configFile);  
  18.         sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);  
  19.     } catch (Exception e) {  
  20.         e.printStackTrace();  
  21.     }  
  22.     }  
  23.       
  24.     //获取SqlMapClient  
  25.     public static SqlMapClient getSqlMap(){  
  26.         return sqlMap;        
  27.     }  
  28. }  

 

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


 

[java] view plaincopyprint?
 
  1. /* 
  2. *调用Ibatis工具类IbatisUtil进行系列CURD操作 
  3. */  
  4.   
  5. import java.sql.SQLException;  
  6. import java.util.List;  
  7.   
  8. import com.ibatis.sqlmap.client.SqlMapClient;  
  9.   
  10. public class IbatisBaseDao {  
  11.       
  12.      /** 
  13.      * 添加对象操作 
  14.      * @param obj 对象实例 sqlMapId SqlMap配置文件中所对应的id 
  15.      * 备注：修改对象操作与之类似 
  16.      */  
  17.     public void save(Object obj,String sqlMapId) {  
  18.         SqlMapClient sqlMap = IbatisUtil.getSqlMap();  
  19.         try {  
  20.             sqlMap.startTransaction();  
  21.   
  22.             sqlMap.update(sqlMapId, obj);  
  23.             sqlMap.commitTransaction();  
  24.         } catch (SQLException e) {  
  25.             e.printStackTrace();  
  26.         } finally {  
  27.             try {  
  28.                 sqlMap.endTransaction();  
  29.             } catch (SQLException e) {  
  30.                 e.printStackTrace();  
  31.             }  
  32.         }  
  33.     }  
  34.       
  35.     /* 
  36.      * 删除对象操作 
  37.      * @param objId sqlMapId SqlMap配置文件中所对应的id 
  38.      * 备注：objId可以为String类型，根据不同的数据库设计决定传参类型 
  39.      */  
  40.     public void delete(Integer objId,String sqlMapId) {  
  41.         SqlMapClient sqlMap = IbatisUtil.getSqlMap();  
  42.         try {  
  43.             sqlMap.startTransaction();  
  44.             sqlMap.update(sqlMapId, objId);  
  45.             sqlMap.commitTransaction();  
  46.         } catch (SQLException e) {  
  47.             e.printStackTrace();  
  48.         } finally {  
  49.             try {  
  50.                 sqlMap.endTransaction();  
  51.             } catch (SQLException e) {  
  52.                 e.printStackTrace();  
  53.             }  
  54.         }  
  55.     }  
  56.       
  57.     /* 
  58.      * 获取对象List列表（包含分页） 
  59.      * @param start 分页参数 sqlMapId SqlMap配置文件中所对应的id 
  60.      * 备注：不同数据库支持sql分页的语句可能不一样 
  61.      */  
  62.     @SuppressWarnings("unchecked")  
  63.     public List<Object> getAll(int start,String sqlMapId) {  
  64.         SqlMapClient sqlMap = IbatisUtil.getSqlMap();  
  65.         List<Object> res =  new ArrayList();  
  66.         try {  
  67.             sqlMap.startTransaction();  
  68.             res = sqlMap.queryForList(sqlMapId, start);  
  69.             sqlMap.commitTransaction();  
  70.         } catch (SQLException e) {  
  71.             e.printStackTrace();  
  72.         } finally {  
  73.             try {  
  74.                 sqlMap.endTransaction();  
  75.             } catch (SQLException e) {  
  76.                 e.printStackTrace();  
  77.             }  
  78.         }  
  79.         return res;  
  80.     }  
  81. }  


 

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

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

 

代码实例：

* IbatisBaseDao：继承Spring的SqlMapClientDaoSupport

 

[java] view plaincopyprint?
 
  1. import java.io.Serializable;  
  2. import java.sql.SQLException;  
  3. import java.util.List;  
  4. import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;  
  5.   
  6. /** 
  7.  * IBatis Dao的泛型基类. 
  8.  * 继承于Spring的SqlMapClientDaoSupport 
  9.  */  
  10. @SuppressWarnings("unchecked")  
  11. public class IBatisBaseDao1 extends SqlMapClientDaoSupport {  
  12.   
  13.      public static final String POSTFIX_INSERT = ".insert";  
  14.      public static final String POSTFIX_UPDATE = ".update";  
  15.      public static final String POSTFIX_DELETE = ".delete";  
  16.      public static final String POSTFIX_DELETE_PRIAMARYKEY = ".deleteByPrimaryKey";  
  17.      public static final String POSTFIX_SELECT = ".select";  
  18.    
  19.      /** 
  20.      * 根据ID获取对象 
  21.      * 
  22.      * @throws BaseException 
  23.      * @throws SQLException 
  24.      */  
  25.      public <T> T get(Class<T> entityClass, Serializable id) throws SQLException {  
  26.        T o = (T) getSqlMapClient().queryForObject(entityClass.getName() + POSTFIX_SELECT, id);  
  27.        return o;  
  28.      }  
  29.       
  30.     /** 
  31.      * 新增对象 
  32.      * 
  33.      * @throws SQLException 
  34.      */  
  35.      public void insert(Object o) throws SQLException {  
  36.          getSqlMapClient().insert(o.getClass().getName() + POSTFIX_INSERT, o);  
  37.      }  
  38.   
  39.      /** 
  40.      * 保存对象 
  41.      * 
  42.      * @throws SQLException 
  43.      */  
  44.      public int update(Object o) throws SQLException {  
  45.          return getSqlMapClient().update(o.getClass().getName() + POSTFIX_UPDATE, o);  
  46.      }  
  47.   
  48.      /** 
  49.      * 删除对象 
  50.      * 
  51.      * @throws SQLException 
  52.      */  
  53.      public int remove(Object o) throws SQLException {  
  54.          return getSqlMapClient().delete(o.getClass().getName() + POSTFIX_DELETE, o);  
  55.      }  
  56.   
  57.      /** 
  58.      * 根据ID删除对象 
  59.      * 
  60.      * @throws SQLException 
  61.      */  
  62.      public <T> int removeById(Class<T> entityClass, Serializable id) throws SQLException {  
  63.          return getSqlMapClient().delete(entityClass.getName() + POSTFIX_DELETE_PRIAMARYKEY, id);  
  64.      }  
  65.       
  66.      /** 
  67.      * 获取全部对象 
  68.      * @throws SQLException 
  69.      */  
  70.      public <T> List<T> getAll(Class<T> entityClass) throws SQLException {  
  71.          return getSqlMapClient().queryForList(entityClass.getName() + POSTFIX_SELECT, null);  
  72.      }  
  73. }  

 

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

/*****************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的二级缓存体系。

分享到：
| 要想学好SQL语句必会的50题，也是考试常考 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ibatis例子，解压就能用，快速理解使用ibatis

    Ibatis 提供了动态 SQL 支持，能够处理复杂的查询逻辑，同时避免了 JDBCTemplate 和 Hibernate 等框架中的过度封装。它的主要优势在于灵活性、性能优化以及对 SQL 的直接控制。 **2. Ibatis 的核心组件** - **...

    跟我学Spring3（8.1）对ORM的支持之概述Java

    Spring的ORM支持还包括对JDBC的高级封装，如JdbcTemplate和SimpleJdbcInsert等，这些工具类使得使用JDBC进行数据库操作更加简洁和安全。此外，Spring还支持数据源的管理，以及声明式和编程式的事务管理，确保了数据...

    hiberante基础介绍

    4. **Apache DBUtils** 和 **Spring JDBCTemplate**：这两个框架对 SQL 语句进行了封装，但相比 ORM 框架，它们的抽象程度较低，需要更多的手动操作。 **使用 Hibernate 的原因** Hibernate 通过封装 JDBC，减少了...

    Hitis-src-1.0.jar

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    spring几种Dao支持配置

    Spring通过`JdbcTemplate`和`SimpleJdbcInsert`等类提供了对JDBC的抽象，减少了直接使用JDBC代码的繁琐性。`JdbcTemplate`提供了一组模板方法，如`queryForList`、`update`等，用于执行SQL查询和更新操作。`...

    spring-orm源码

    Spring-ORM对多种ORM框架进行了封装，如Hibernate、JPA和iBatis。例如，对于Hibernate，Spring提供了HibernateTemplate和HibernateDaoSupport类，它们简化了与Hibernate Session的交互。源码中可以看到这些类如何...

    Hitis V1.2.2

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    dao.rar_spring-dao

    DAO（Data Access Object）模式是Java开发中常用的一种设计模式，用于封装对数据库的操作，使得业务逻辑层与数据访问层解耦。Spring框架提供了对DAO的支持，通过依赖注入（DI）和面向切面编程（AOP）简化了数据访问...

    Hitis V1.2.1

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    Hitis V1.1

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    Hitis V1.1.1

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    Hitis V1.2

    (4)在Hitis中，你可以与spring无缝集成，借助于JdbcTemplate，你可以快速封装出自己的dao层 (5)在ibatis中，想做物理分页，你必须在写一个列表sql，还要写一个90%一样的总页数的sql，不仅如此，你还要在列表sql外包...

    java的轻量级orm工具包jdao.zip

     如果你觉得hibernate，ibatis等orm框架过于笨重，不烦试下jdao，它可以在团队开发中规范团队持久层代码，较少开发量，特别在单表操作上基本是对象操作，对于复杂SQL查询也有较好的封装。一、使用DAO方式操作数据：...

    Java技术与就业指导

    远程调用技术如Dwr和WebService实现了不同应用间的通信，JDBC用于数据库操作，ORM框架如Hibernate、JdbcTemplate、Ibatis则简化了数据库交互。 数据库层面，需要熟悉SQL语言，包括MySQL、Oracle、SQL Server和DB2等...

    java 通用数据访问层dal

    java dal 封装的通用dao 数据访问层，如果你不喜欢用Hibernate、Mybaits这类ORM框架，喜欢Spring JdbcTemplate或DbUtils，那么可以试试这个封装的通用dal

    Spring杂谈

    - **对ORM的支持**：支持主流ORM框架的集成，如Hibernate、iBatis等。提供了一些辅助类，如LocalSessionFactoryBean，用于简化与ORM框架的集成。 ### Spring MVC Spring MVC是一个基于Servlet API的MVC框架，用于...

    Java技术与就业指导（张孝祥）.ppt

    数据库访问方面，JDBC是Java连接数据库的标准接口，而Hibernate、JDBC Util、JPA、JdbcTemplate、Ibatis等ORM框架则简化了数据库操作。远程调用技术如Dwr和WebService实现了不同系统间的通信。 在面试准备中，了解...

    java开发常用设计模式

    2. **AppFuse框架**：集成了一系列流行的技术栈，包括Spring、Hibernate、iBATIS等，通过研究AppFuse的源代码，可以加深对Spring的理解。 3. **Spring开发指南**：夏昕著的《Spring开发指南》是一本优秀的入门书籍...

    Java技术与就业指导（张孝祥）

    数据库访问层涉及JDBC、Hibernate、DbUtil、JPA、JdbcTemplate和iBatis等技术，它们简化了与数据库的交互。此外，XML处理和编程设计也是必不可少的技能。远程调用技术如Dwr和WebService使得不同系统间的通信成为可能...

Magicbox
Global site tag (gtag.js) - Google Analytics