BaseDao模板

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

/*************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 plain copy print ?

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 plain copy print ?

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 plain copy print ?

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 plain copy print ?

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 plain copy print ?

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 plain copy print ?

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

//ibatisDao

package com.test.dao;

import java.util.List;

import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
public class BaseDAO<E> extends SqlMapClientDaoSupport{
    //查询多条信息
    @SuppressWarnings("unchecked")
protected List<E> select(String statementName,E Objectparameter) throws Exception{
        List<E> list ;
        list = this.getSqlMapClientTemplate().queryForList(statementName,Objectparameter);
        return list;
    }
    //查询一条信息
    protected int selectSingle (String statementName,E Objectparameter) throws Exception{
       Object obj = this.getSqlMapClientTemplate().queryForObject(statementName,Objectparameter);
       int max =0;
       if(obj != null) {
           max = (Integer) obj;
       }
        return max;
    }
   
    //删除信息
    protected int delete(String statementName,E parameterObject) throws Exception{
        int flag = 0;
        flag = this.getSqlMapClientTemplate().delete(statementName, parameterObject);
        return flag;
    }
   
    //增加信息
    protected int insert(String statementName, E parameterObject)throws Exception{
     
        int flag = 0;
        Object obj = this.getSqlMapClientTemplate().insert(statementName, parameterObject);
        if(obj != null){
            flag = (Integer) obj;
        }
        return flag;
    }
    //更新信息
    protected int update(String statementName,E parameterObject) throws Exception{
        int flag = 0;
        flag = this.getSqlMapClientTemplate().update(statementName, parameterObject);
        return flag;
    }
   
}