hibernate基础dao类

  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 }

  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 }

 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 }

 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 }