当前位置:首页 > 开发 > 系统架构 > 架构 > 正文

02-BaseDao的封装及实现

发表于: 2014-05-23   作者:曹悦2014   来源:转载   浏览:
摘要:      此篇博文仅代表个人观点,由于本人经验尚浅,如有错漏之处请私信指正,谢谢           从程序的维护以及扩展性进行考虑,对程序进行分层 view层,展现给用户并进行交互 controller层,与view进行直接的交互,访问serv
     此篇博文仅代表个人观点,由于本人经验尚浅,如有错漏之处请私信指正,谢谢     

     从程序的维护以及扩展性进行考虑,对程序进行分层
  • view层,展现给用户并进行交互
  • controller层,与view进行直接的交互,访问service层,隐藏底层的代码
  • service层,封装了业务逻辑的处理,访问dao层
  • dao层,封装了对model的操作,增删改查等等,与数据库进行交互
  • model层,封装了实体类

     为了从代码的简洁性以及复用性来考虑,对dao层进行封装,使其能进行基础的数据库操作.
提供本人的BaseDao
     
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;
	}


	

}



02-BaseDao的封装及实现

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
对于hibernate虽然是开源的,但是在实际的使用中,有的开发者还是不愿意放心的使用,首先对于一般的
在用Cocos2DX引擎开发游戏的过程中,我们经常需要弹出一个对话框或者提示框,通知玩家一些必要的信
http://developer.51cto.com 2009-08-19 09:36 佚名 CSDN 摘要:这里介绍ADO封装类,微软公司相继推
封装CIImage实现实时渲染 CIImage属于CoreImage里面的东东,用来渲染图片的,为什么要封装它呢?其实很
为了充分利用多核的优势,我们利用多线程来进行任务处理,但线程也同样不能滥用,会带来一下几个问
这周做计算机网络课程设计,在几个题目中选了个MAC帧的封装. 首先看最后结果: 这里有个bug,不知道为
package com.yuxinglab.poi.test; import java.io.File; import java.io.FileNotFoundException; im
  现在学习java的人实在是太多了,什么培训学校,什么高校,基本上是学习java的,以至于现在java
RPC(远程过程调用)是一种调用远程程序的协议,可以实现RPC的方案很多,比如RMI、Hessian,还有公
数据model,此model只存在getXXX和setXXX方法,不存在isXXX方法。 /** * Created by lgq on 2015/8/
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号