02-BaseDao的封装及实现_JAVA_编程开发_程序员俱乐部

     此篇博文仅代表个人观点，由于本人经验尚浅，如有错漏之处请私信指正，谢谢     

     从程序的维护以及扩展性进行考虑，对程序进行分层

• view层，展现给用户并进行交互
• controller层，与view进行直接的交互，访问service层，隐藏底层的代码
• service层，封装了业务逻辑的处理，访问dao层
• dao层，封装了对model的操作，增删改查等等，与数据库进行交互
• model层，封装了实体类

     为了从代码的简洁性以及复用性来考虑，对dao层进行封装，使其能进行基础的数据库操作.
提供本人的BaseDao
     

class="java">
package cn.cy.dao;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 基础数据库操作类
 * 其他DAO继承此类获取常用的数据库操作方法
 * @author 曹悦
 * @param <T>  模型
 */
public interface BaseDaoI<T> {

	
	/**
	 * 保存一个对象
	 * 
	 * @param o 对象
	 *            
	 * @return 对象的ID
	 */
	public Serializable save(T o);

	/**
	 * 删除一个对象
	 * 
	 * @param o  对象
	 *           
	 */
	public void delete(T o);

	/**
	 * 更新一个对象
	 * 
	 * @param o  对象
	 *           
	 */
	public void update(T o);

	/**
	 * 保存或更新一个对象
	 * 
	 * @param o 对象
	 *            
	 */
	public void saveOrUpdate(T o);

	/**
	 * 通过主键获得对象
	 * 
	 * @param c 类名.class
	 *            
	 * @param id  主键
	 *           
	 * @return 对象
	 */
	public T get(Class<T> c, Serializable id);

	/**
	 * 通过HQL语句获取一个对象
	 * 
	 * @param hql  HQL语句
	 *           
	 * @return 对象
	 */
	public T get(String hql);

	/**
	 * 通过HQL语句获取一个对象
	 * 
	 * @param hql  HQL语句
	 *           
	 * @param params  参数
	 *           
	 * @return 对象
	 */
	public T get(String hql, Map<String, Object> params);

	/**
	 * 获得对象列表
	 * 
	 * @param hql HQL语句
	 *            
	 * @return List
	 */
	public List<T> find(String hql);

	/**
	 * 获得对象列表
	 * 
	 * @param hql  HQL语句
	 *           
	 * @param params  参数
	 *           
	 * @return List
	 */
	public List<T> find(String hql, Map<String, Object> params);

	/**
	 * 获得分页后的对象列表
	 * 
	 * @param hql HQL语句
	 *            
	 * @param page  要显示第几页
	 *           
	 * @param rows 每页显示多少条
	 *            
	 * @return List
	 */
	public List<T> find(String hql, int page, int rows);

	/**
	 * 获得分页后的对象列表
	 * 
	 * @param hql  HQL语句
	 *           
	 * @param params 参数
	 *            
	 * @param page 要显示第几页
	 *            
	 * @param rows  每页显示多少条
	 *           
	 * @return List
	 */
	public List<T> find(String hql, Map<String, Object> params, int page, int rows);

	/**
	 * 统计数目
	 * 
	 * @param hql  HQL语句(select count(*) from T)
	 *           
	 * @return long
	 */
	public Long count(String hql);

	/**
	 * 统计数目
	 * 
	 * @param hql  HQL语句(select count(*) from T where xx = :xx)
	 *           
	 * @param params  参数
	 *           
	 * @return long
	 */
	public Long count(String hql, Map<String, Object> params);

	/**
	 * 执行一条HQL语句
	 * 
	 * @param hql  HQL语句
	 *           
	 * @return 响应结果数目
	 */
	public int executeHql(String hql);

	/**
	 * 执行一条HQL语句
	 * 
	 * @param hql HQL语句
	 *            
	 * @param params 参数
	 *            
	 * @return 响应结果数目
	 */
	public int executeHql(String hql, Map<String, Object> params);

	/**
	 * 获得结果集
	 * 
	 * @param sql SQL语句
	 *            
	 * @return 结果集
	 */
	public List<Object[]> findBySql(String sql);

	/**
	 * 获得结果集
	 * 
	 * @param sql  SQL语句
	 *           
	 * @param page   要显示第几页
	 *          
	 * @param rows    每页显示多少条
	 *         
	 * @return 结果集
	 */
	public List<Object[]> findBySql(String sql, int page, int rows);
	/**
	 * 
	 * 
	 * @param c 类名.class
	 * @param sql SQL语句
	 * @param page 要显示第几页
	 * @param rows 每页显示多少条
	 * @return 结果集
	 */
	public List<T> findBySql(Class<T> c,String sql, int page, int rows);


	/**
	 * 获得结果集
	 * 
	 * @param sql SQL语句
	 *            
	 * @param params  参数
	 *           
	 * @return 结果集
	 */
	public List<Object[]> findBySql(String sql, Map<String, Object> params);

	/**
	 * 获得结果集
	 * 
	 * @param sql SQL语句
	 *            
	 * @param params 参数
	 *            
	 * @param page 要显示第几页
	 *            
	 * @param rows 每页显示多少条
	 *            
	 * @return 结果集
	 */
	public List<Object[]> findBySql(String sql, Map<String, Object> params, int page, int rows);
	
	/**
	 * 
	 * @param sql SQL语句
	 * @return 
	 */
	public  ArrayList<Map<String, Object>> queryBySql(String sql);
	

	/**
	 * 执行SQL语句
	 * 
	 * @param sql  SQL语句
	 *           
	 * @return 响应行数
	 */
	public int executeSql(String sql);

	/**
	 * 执行SQL语句
	 * 
	 * @param sql  SQL语句
	 *           
	 * @param params  参数
	 *           
	 * @return 响应行数
	 */
	public int executeSql(String sql, Map<String, Object> params);
	
	/**
	 * 统计数目
	 * 
	 * @param sql SQL语句
	 * 			  
	 * @return 统计出的数值
	 */
	public Long countBySql(String sql);
	
	/**
	 *  统计数目
	 * 
	 * @param sql SQL语句
	 *           
	 * @param params  参数
	 * 
	 * @return 统计出的数值
	 */
	public Long countBySql(String sql,Map<String, Object> params);
	

}

      以及实现了BaseDao接口的BaseDaoImpl类

package cn.cy.dao.Impl;

import java.io.Serializable;
import java.math.BigInteger;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.jdbc.ReturningWork;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import cn.cy.dao.BaseDaoI;

@Repository
public class BaseDaoImpl<T> implements BaseDaoI<T> {

	@Autowired
	private SessionFactory sessionFactory;

	/**
	 * 获得当前事物的session
	 * 
	 * @return org.hibernate.Session
	 */
	public Session getCurrentSession() {
		return this.sessionFactory.getCurrentSession();
	}

	
	@Override
	public Serializable save(T o) {
		if (o != null) {
			return this.getCurrentSession().save(o);
		}
		return null;
	}

	@Override
	public void delete(T o) {
		if(null != o ){
			this.getCurrentSession().delete(o);
		}
	}

	@Override
	public void update(T o) {
		if(null != o ){
			this.getCurrentSession().update(o);
		}
	}

	@Override
	public void saveOrUpdate(T o) {
		if(null != o){
			this.getCurrentSession().saveOrUpdate(o);
		}	
	}


	@Override
	public T get(Class<T> c, Serializable id) {
		if(null != c && null!=id){
			return (T) this.getCurrentSession().get(c, id);
		}
		return null;
	}

	@Override
	public T get(String hql) {
		if(null != hql && !hql.equalsIgnoreCase("")){
			Query q = this.getCurrentSession().createQuery(hql);
			List<T> l = q.list();
			if(null != l &&l.size()>0 ){
				return (T) l.get(0);
			}
		}
		return null;
	}

	@Override
	public T get(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (params != null && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		List<T> l = q.list();
		if (l != null && l.size() > 0) {
			return l.get(0);
		}
		return null;
	}

	@Override
	public List<T> find(String hql) {
		Query q = this.getCurrentSession().createQuery(hql);
		return q.list();
	}

	@Override
	public List<T> find(String hql, Map<String, Object> params) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (params != null && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.list();
	}

	@Override
	public List<T> find(String hql, int page, int rows) {
		Query q = this.getCurrentSession().createQuery(hql);
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
	}

	@Override
	public List<T> find(String hql, Map<String, Object> params, int page,
			int rows) {
		Query q = this.getCurrentSession().createQuery(hql);
		if (params != null && !params.isEmpty()) {
			for (String key : params.keySet()) {
				q.setParameter(key, params.get(key));
			}
		}
		return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
		
	}

	@Override
	public Long count(String hql) {
		if(null != null && !hql.equalsIgnoreCase("")){
			Query q = this.getCurrentSession().createQuery(hql);
			return (Long) q.uniqueResult();
		}
	    return (long)0;
		
	}

	@Override
	public Long count(String hql, Map<String, Object> params) {
		if(null != null && !hql.equalsIgnoreCase("")){
			Query q = this.getCurrentSession().createQuery(hql);
			if(null != params&&!params.isEmpty()){
				for (String key:params.keySet()){
					q.setParameter(key, params.get(key));
				}
				return (Long) q.uniqueResult();
			}
			
		}
	    return (long)0;
	}

	@Override
	public int executeHql(String hql) {
		if(null != hql&&!hql.equalsIgnoreCase("")){
			Query q = this.getCurrentSession().createQuery(hql);
			return q.executeUpdate();
		}
		return 0;
	}

	@Override
	public int executeHql(String hql, Map<String, Object> params) {
		if(null != hql&&!hql.equalsIgnoreCase("")){
			Query q = this.getCurrentSession().createQuery(hql);
			if(null != params&&!params.isEmpty()){
				for (String key:params.keySet()){
					q.setParameter(key, params.get(key));
				}
			}
			return q.executeUpdate();
		}
		return 0;
	}

	@Override
	public List<Object[]> findBySql(String sql) {
		if(null != sql && !sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			return q.list();
		}
		return null;
	}

	@Override
	public List<Object[]> findBySql(String sql, int page, int rows) {
		if(null != sql && !sql.equalsIgnoreCase("")){
			
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();		
			
		}
		return null;
	}

	@Override
	public List<T> findBySql(Class<T> c, String sql, int page, int rows) {
	if(null != sql && !sql.equalsIgnoreCase("")){
			
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql).addEntity(c);
			return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();		
			
		}
		return null;
	}

	@Override
	public List<Object[]> findBySql(String sql, Map<String, Object> params) {
		if(null !=sql&&!sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			if (params != null && !params.isEmpty()) {
				for (String key : params.keySet()) {
					q.setParameter(key, params.get(key));
				}
			}
			return q.list();
		}
		return null;
	}

	@Override
	public List<Object[]> findBySql(String sql, Map<String, Object> params,
			int page, int rows) {
		if(null != sql &&!sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			if (params != null && !params.isEmpty()) {
				for (String key : params.keySet()) {
					q.setParameter(key, params.get(key));
				}
			}
			return q.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
		}
		
		return null;
	}

	@Override
	public int executeSql(String sql) {
		if(null != sql &&!sql.equalsIgnoreCase("")){
			
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			return q.executeUpdate();
			
		}
		return 0;
	}

	@Override
	public int executeSql(String sql, Map<String, Object> params) {
		if(null != sql &&!sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			if (params != null && !params.isEmpty()) {
				for (String key : params.keySet()) {
					q.setParameter(key, params.get(key));
				}
			}
			return q.executeUpdate();
			
		}
		return 0;
	}

	@Override
	public Long countBySql(String sql) {
		if(null != sql &&!sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			return (Long) q.uniqueResult();
		}
		return (long)0;
	}

	@Override
	public Long countBySql(String sql, Map<String, Object> params) {
		if(null != sql &&!sql.equalsIgnoreCase("")){
			SQLQuery q = this.getCurrentSession().createSQLQuery(sql);
			if (params != null && !params.isEmpty()) {
				for (String key : params.keySet()) {
					q.setParameter(key, params.get(key));
				}
			}
			return (Long) q.uniqueResult();
		}
		return (long)0;
	}


	@Override
	public ArrayList<Map<String, Object>> queryBySql(final String sql) {
		if(null != sql && !sql.equalsIgnoreCase("")){
			Session session=this.getCurrentSession();
			ArrayList<Map<String, Object>> resultarr = null; 
			ResultSetMetaData rsmd = null;
	        ResultSet rs = session.doReturningWork( new ReturningWork<ResultSet>() {
	        	   @Override
                   public ResultSet execute(Connection connection) throws SQLException {
                       
                       PreparedStatement preparedStatement = connection.prepareStatement(sql);
                       ResultSet resultSet = preparedStatement.executeQuery();
                       return resultSet;
                   }
	        	
	        });
	        try {
				rsmd = rs.getMetaData();
				resultarr = new ArrayList<Map<String, Object>>();
				while(rs.next()){
					Map<String, Object> result = new HashMap<String, Object>();
					for(int i=1;i<=rsmd.getColumnCount();i++){
						result.put(rsmd.getColumnLabel(i), rs.getObject(i));
					}
					resultarr.add(result);
				}
				return resultarr;
			} catch (SQLException e) {
				e.printStackTrace();
			}     
		}
			
		return null;
	}


	

}