hibernate基礎dao類，hibernate基礎dao
功能：數據庫的保存、更新、刪除；sql、hql查詢；分頁查詢；調用存儲過程
基礎dao類，BaseDaoImpl.class
![]()
1 import java.io.Serializable;
2 import java.sql.CallableStatement;
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.text.MessageFormat;
7 import java.util.ArrayList;
8 import java.util.List;
9 import java.util.Map;
10
11 import org.hibernate.Criteria;
12 import org.hibernate.Query;
13 import org.hibernate.Session;
14 import org.hibernate.criterion.DetachedCriteria;
15 import org.hibernate.criterion.Projections;
16 import org.hibernate.jdbc.Work;
17 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
18
19 public class BaseDaoImpl<T extends Serializable> extends HibernateDaoSupport implements BaseDao<T>{
20 public BaseDaoImpl(){
21 super();
22 }
23
24 /**
25 * 返回數據庫session對象
26 * @return
27 */
28 protected Session getCurrentSession(){
29 return getHibernateTemplate().getSessionFactory().getCurrentSession();
30 }
31
32 /**
33 * 保存實體對象
34 * @param entity 實體對象
35 */
36 @Override
37 public void save(T entity){
38 Session session = getCurrentSession();
39 session.save(entity);
40 session.flush();
41 session.evict(entity);
42 }
43
44 /**
45 * 更新實體對象
46 * @param 實體對象
47 */
48 @Override
49 public void update(T entity){
50 Session session = getCurrentSession();
51 session.update(entity);
52 session.flush();
53 session.evict(entity);
54 }
55
56 /**
57 * 保存或更新實體對象
58 * @param entity 實體對象
59 */
60 @Override
61 public void saveOrUpdate(T entity) {
62 Session session = getCurrentSession();
63 session.saveOrUpdate(entity);
64 session.flush();
65 session.evict(entity);
66 }
67
68 /**
69 * 刪除實體對象
70 * @param entity 實體對象
71 */
72 @Override
73 public void delete(T entity){
74 Session session = getCurrentSession();
75 session.delete(entity);
76 session.flush();
77 session.evict(entity);
78 }
79
80 /**
81 * 查詢hql語句，返回唯一結果
82 * @param hql
83 */
84 @Override
85 public Object findUniqueResult(String hql){
86 Query query = getCurrentSession().createQuery(hql);
87 return query.uniqueResult();
88 }
89
90 /**
91 * 執行sql語句，更新數據庫
92 * @param sql
93 */
94 @Override
95 public void updateBySql(final String sql){
96 getSession().doWork(new Work() {
97 @Override
98 public void execute(Connection connection) throws SQLException {
99 connection.prepareStatement(sql).executeUpdate();
100 }
101 });
102 }
103
104 /**
105 * 通過Criteria對象查詢，返回實體對象結果集
106 * @param detachedCriteria 離線的Criteria對象
107 * @return 實體對象結果集
108 */
109 @Override
110 public List findByCriteria(DetachedCriteria detachedCriteria){
111 Criteria criteria = detachedCriteria.getExecutableCriteria(getCurrentSession());
112 List records = criteria.list();
113 return records;
114 }
115
116 /**
117 * 通過sql語句查詢，返回map對象結果集
118 * @param sql
119 * @return map對象結果集
120 */
121 @Override
122 public List<Map<String, Object>> findBySql(final String sql){
123 final List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
124 getSession().doWork(new Work() {
125 @Override
126 public void execute(Connection connection) throws SQLException {
127 ResultSet rs = connection.prepareStatement(sql).executeQuery();
128 result.addAll(RsHelper.rSToList(rs));
129 }
130 });
131 return result;
132 }
133
134 /**
135 * 查詢sql語句，返回唯一結果
136 * @param sql
137 */
138 @Override
139 public Object findUniqueResultBySql(String sql) {
140 return getCurrentSession().createSQLQuery(sql.toString()).uniqueResult();
141 }
142
143 /**
144 * 通過Criteria對象查詢，返回結果集的記錄數
145 * @param detachedCriteria 離線的Criteria對象
146 * @return 結果集的記錄數
147 */
148 @Override
149 public long getCount(DetachedCriteria detachedCriteria) {
150 Criteria criteria = detachedCriteria.getExecutableCriteria(getCurrentSession());
151 Object object = criteria.setProjection(Projections.rowCount()).uniqueResult();
152 criteria.setProjection(null);
153 Long totalRow = Long.valueOf(String.valueOf(object));
154 return totalRow;
155 }
156
157 /**
158 * 通過Criteria對象進行分頁查詢，返回實體對象結果集
159 * @param pageNum 第幾頁
160 * @param pageSize 每頁大小
161 * @param detachedCriteria 離線的Criteria對象
162 * @return 實體對象結果集
163 */
164 @Override
165 public List<T> findPage(int pageNum, int pageSize,
166 DetachedCriteria detachedCriteria){
167 Criteria criteria = detachedCriteria.getExecutableCriteria(getCurrentSession());
168 List<T> records = criteria.setFirstResult((pageNum-1) * pageSize).setMaxResults(pageSize).list();
169 return records;
170 }
171
172 /**
173 * 通過sql語句，進行分頁查詢，返回分頁對象
174 * @param pageNum 第幾頁
175 * @param pageSize 每頁大小
176 * @param sql
177 * @return 分頁對象
178 */
179 @Override
180 public Pagination findPage(final int pageNum, final int pageSize,final String sql){
181 final Pagination page = new Pagination();
182 getSession().doWork(new Work() {
183 @Override
184 public void execute(Connection connection) throws SQLException {
185 String countSql = MessageFormat.format("select count(*) from ({0}) page", sql);
186 ResultSet rs = connection.prepareStatement(countSql).executeQuery();
187 page.setTotal(Long.valueOf(RsHelper.getUniqueResult(rs).toString()));
188
189 long firstResult = (pageNum - 1)*pageSize;
190 String selectSql = MessageFormat.format("select * from ({0}) page limit {1},{2}", sql, firstResult, firstResult+pageSize);
191 page.setRows(RsHelper.rSToList(connection.prepareStatement(selectSql).executeQuery()));
192 }
193 });
194
195 return page;
196 }
197
198 /**
199 * 調用存儲過程，返回單結果集
200 * @param proceName 存儲過程名稱
201 * @param params 輸入參數集合
202 * @return map對象結果集
203 */
204 public List<Map<String, Object>> callProcedure(String proceName, final List<Object> params){
205 final List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
206 final StringBuffer sql = new StringBuffer();
207 sql.append("{call " + proceName + "(");
208 for(int i=0; params!=null && i<params.size(); i++){
209 sql.append("?");
210 if(i+1!=params.size())
211 sql.append(",");
212 }
213 sql.append(")}");
214 getSession().doWork(new Work() {
215 @Override
216 public void execute(Connection connection) throws SQLException {
217 CallableStatement statement = connection.prepareCall(
218 sql.toString());
219 for(int i=0; i<params.size(); i++){
220 statement.setObject(i+1, params.get(i));//設置參數
221 }
222
223 result.addAll(RsHelper.rSToList(statement.executeQuery()));
224 }
225 });
226
227 return result;
228 }
229
230 }
View Code
基礎dao類接口，BaseDao.class
![]()
1 import java.io.Serializable;
2 import java.util.List;
3 import java.util.Map;
4
5 import org.hibernate.criterion.DetachedCriteria;
6
7 /**
8 * 統一數據訪問接口
9 */
10 public interface BaseDao<T extends Serializable> {
11
12 /**
13 * 保存實體對象
14 * @param entity 實體對象
15 */
16 public void save(T entity);
17
18 /**
19 * 更新實體對象
20 * @param 實體對象
21 */
22 public void update(T entity);
23
24 /**
25 * 保存或更新實體對象
26 * @param entity 實體對象
27 */
28 public void saveOrUpdate(T entity);
29
30 /**
31 * 刪除實體對象
32 * @param entity 實體對象
33 */
34 public void delete(T entity);
35
36 /**
37 * 查詢hql語句，返回唯一結果
38 * @param hql
39 */
40 public Object findUniqueResult(String hql);
41
42 /**
43 * 執行sql語句，更新數據庫
44 * @param sql
45 */
46 public void updateBySql(String sql);
47
48 /**
49 * 通過Criteria對象查詢，返回實體對象結果集
50 * @param detachedCriteria 離線的Criteria對象
51 * @return 實體對象結果集
52 */
53 public List findByCriteria(DetachedCriteria detachedCriteria);
54
55 /**
56 * 通過sql語句查詢，返回map對象結果集
57 * @param sql
58 * @return map對象結果集
59 */
60 public List<Map<String, Object>> findBySql(String sql);
61
62 /**
63 * 查詢sql語句，返回唯一結果
64 * @param sql
65 */
66 public Object findUniqueResultBySql(String sql);
67
68 /**
69 * 通過Criteria對象查詢，返回結果集的記錄數
70 * @param detachedCriteria 離線的Criteria對象
71 * @return 結果集的記錄數
72 */
73 public long getCount(DetachedCriteria detachedCriteria);
74
75 /**
76 * 通過Criteria對象進行分頁查詢，返回實體對象結果集
77 * @param pageNum 第幾頁
78 * @param pageSize 每頁大小
79 * @param detachedCriteria 離線的Criteria對象
80 * @return 實體對象結果集
81 */
82 public List<T> findPage(int pageNum, int pageSize, DetachedCriteria detachedCriteria);
83
84 /**
85 * 通過sql語句，進行分頁查詢，返回分頁對象
86 * @param pageNum 第幾頁
87 * @param pageSize 每頁大小
88 * @param sql
89 * @return 分頁對象
90 */
91 public Pagination findPage(int pageNum, int pageSize, String sql); // 查找分頁對象列表
92
93 /**
94 * 調用存儲過程，返回單結果集
95 * @param proceName 存儲過程名稱
96 * @param params 輸入參數集合
97 * @return map對象結果集
98 */
99 public List<Map<String, Object>> callProcedure(String proceName, final List<Object> params);
100 }
View Code
數據庫結果集幫助器，RsHelper.class
![]()
1 import java.sql.ResultSet;
2 import java.sql.ResultSetMetaData;
3 import java.sql.SQLException;
4 import java.util.ArrayList;
5 import java.util.Collections;
6 import java.util.HashMap;
7 import java.util.List;
8 import java.util.Map;
9
10 /**
11 * 數據庫結果集幫助器
12 */
13 public class RsHelper {
14 /**
15 * 返回結果集中的唯一結果，沒有則返回null
16 * @param rs 結果集
17 * @return
18 * @throws SQLException
19 */
20 public static Object getUniqueResult(ResultSet rs) throws SQLException{
21 if(rs.next()) {
22 return rs.getObject(1);
23 }
24 return null;
25 }
26
27 /**
28 * 將實體結果集對象轉換為map對象結果集
29 * @param rs 實體結果集對象
30 * @return map對象結果集
31 * @throws SQLException
32 */
33 public static List<Map<String,Object>> rSToList(ResultSet rs) throws SQLException {
34 if (rs == null)
35 return Collections.EMPTY_LIST;
36 ResultSetMetaData md = rs.getMetaData(); //得到結果集(rs)的結構信息，比如字段數、字段名等
37 int columnCount = md.getColumnCount(); //返回此 ResultSet 對象中的列數
38 List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
39 Map<String,Object> rowData = new HashMap<String,Object>();
40 while (rs.next()) {
41 rowData = new HashMap<String,Object>(columnCount);
42 for (int i = 1; i <= columnCount; i++) {
43 rowData.put(md.getColumnName(i), rs.getObject(i));
44 }
45 list.add(rowData);
46 }
47 return list;
48 }
49 }
View Code
分頁對象類，Pagination.class
![]()
1 import java.util.ArrayList;
2 import java.util.List;
3
4 /**
5 * 分頁對象，一般用於響應頁面請求
6 */
7 public class Pagination {
8 /**
9 * 總記錄數
10 */
11 private Long total = 0l;
12
13 /**
14 * 記錄集合
15 */
16 private List rows = new ArrayList();
17
18 public Long getTotal() {
19 return total;
20 }
21 public void setTotal(Long total) {
22 this.total = total;
23 }
24
25 public List getRows() {
26 return rows;
27 }
28 public void setRows(List rows) {
29 this.rows = rows;
30 }
31 }
View Code
