`
曹悦2014
  • 浏览: 5394 次
  • 性别: Icon_minigender_1
  • 来自: 哈尔滨
社区版块
存档分类
最新评论

02-BaseDao的封装及实现

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

     从程序的维护以及扩展性进行考虑，对程序进行分层
  • 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;
	}


	

}


分享到：
| 01-项目的建立以及配置文件的修改
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    dbutils封装ORM 实现BaseDAO

    `BaseDAO` 的封装则是一种常见的设计模式，用于简化数据访问对象（DAO）的实现，使得业务代码更加简洁、可维护。 `dbutils` 主要包含以下几个核心概念和功能： 1. **QueryRunner**: QueryRunner类是dbutils的主要...

    spring4+hibernate4 封装BaseDao增删改查以及分页,，支持jdk1.7，不支持jdk1.8

    3. **BaseDao封装**：BaseDao是一般用于数据访问层的基类，它包含了通用的CRUD操作。在这个项目中，BaseDao可能已经定义了如`save()`, `update()`, `delete()`, `findById()`, `findAll()`等方法，以供其他特定的DAO...

    常用的BaseDAO及其实现

    "常用的BaseDAO及其实现" BaseDAO是Java中一种常用的数据访问对象（DAO），它提供了统一的数据访问接口，封装了数据访问的基本操作。BaseDAO通常是通过继承HibernateDaoSupport类实现的。 BaseDAO的主要功能包括：...

    BaseDao的封装

    在IT行业中，数据库操作是应用程序的核心部分，而`BaseDao`的封装则是一种常见的设计模式，用于简化数据库访问层（DAO）的实现。这个模式的主要目的是提高代码的可复用性和可维护性，减少重复的SQL操作代码。下面...

    basedao_basedao数据库_

    BaseDao是一种设计模式，它通常被用来作为数据库访问对象（DAO）的基础，用于封装数据库的基本CRUD（创建、读取、更新、删除）操作。这种模式可以提高代码复用性，降低业务逻辑与数据访问层的耦合度。 首先，我们来...

    企业通用BaseDao方法集

    BaseDao的设计理念是将数据库操作的核心逻辑进行抽象，减少重复代码，使得开发人员可以更专注于业务逻辑的实现。 首先，BaseDao的核心功能之一是提供CRUD（创建、读取、更新、删除）操作。这些基本方法包括： 1. `...

    基于注解反射封装的BaseDao（支持一对多查询）

    总结来说，基于注解反射封装的 `BaseDao` 实现了一种灵活的方法，可以处理实体类之间的一对多查询，减少了重复代码，提高了代码的复用性和可维护性。在实际项目中，我们可以通过继承 `BaseDao` 并指定具体的实体类型...

    基于JDBC封装的BaseDao(实例代码)

    在Java开发中，JDBC...总的来说，基于JDBC封装的`BaseDao`是一个基础的数据库操作模板，它通过泛型和反射实现了对不同实体类的通用操作。然而，实际项目中往往需要更全面和完善的解决方案，以满足复杂的业务需求。

    Mybatis通用DAO设计封装（mybatis）

    Mybatis通用DAO设计封装主要涉及的是在Java开发中如何高效地使用Mybatis框架进行数据库操作。Mybatis是一款轻量级的持久层框架，它避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。通过提供自定义SQL、存储...

    baseDAO及其实现案例、jdbcUtil工具类、数据池c3p0、dbcp、druid驱动及实现方式

    在提供的`baseDAO案例及测试.zip`文件中，我们可以看到如何结合`Customer`类来实现具体的数据库操作。 `JDBCUtil`工具类是对JDBC API的进一步封装，它简化了数据库连接的创建、关闭等过程，避免了资源泄露。常见的`...

    基于hibernate的baseDao

    本压缩包提供的"baseDAO"文件，包含了一个详细注释的BaseDAO实现，旨在提供一种易于理解和使用的Hibernate基础操作模板。 1. **Hibernate框架简介** Hibernate是一个开源的对象关系映射（ORM）框架，它简化了Java...

    基于SpringJDBC的BaseDAO

    ### 基于Spring JDBC的BaseDAO实现与应用 #### 概述 在Java开发领域，尤其是企业级应用开发中，持久层框架是至关重要的组件之一。Spring框架提供了多种方式来处理数据库操作，其中Spring JDBC模块是轻量级且功能...

    Spring声明式事务及BaseDao完整版

    本篇将重点讲解Spring的声明式事务管理和BaseDao的设计与实现。 一、Spring声明式事务管理 1. **什么是事务**：事务是数据库操作的基本单元，它保证了数据的一致性和完整性。一个事务中的所有操作要么全部成功，...

    hibernate>>BaseDAO

    通过以上这些知识点，我们可以理解`BaseDAO`在Hibernate应用中的核心作用，它是连接业务逻辑和数据库操作的桥梁，通过抽象出通用功能，使得开发者可以更加专注于业务需求的实现，而不是繁琐的数据库交互细节。...

    精简封装Basedao.pdf

    总之，`BaseDao`接口及其实现是Java中数据访问层设计的一个常见模式，用于封装数据库操作，提供通用的方法供业务逻辑调用。这样的设计有助于减少代码重复，提高代码质量，同时也便于更换不同的数据库引擎。

    hibernate BASEDAO

    在Java的持久化框架Hibernate中，BaseDAO（Base Data Access Object）是一种常见的设计模式，用于封装数据库操作，提供一套标准的方法来实现CRUD（Create、Read、Update、Delete）操作。这种模式使得业务层可以更加...

    BaseDao标准模板

    `BaseDao`（数据访问对象）是一种在Java应用中广泛使用的模式，用于封装对数据库的操作。该模式的主要目的是将业务逻辑与数据访问逻辑分离，使得程序结构更加清晰、易于维护。 ### 2. 包名与导入包 - **包名**：`...

    mybatis basedao

    MyBatis BaseDAO 是一种基于 MyBatis 框架的工具类库，它旨在简化数据库操作，通过封装常见的CRUD（Create、Read、Update、Delete）方法，为开发者提供便利，减少重复代码，提高开发效率。在Java Web 开发中，...

    Android数据库ORM封装

    本文将详细介绍如何在Android中进行数据库ORM的封装，并通过一个名为`DataBaseDemo`的示例项目来展示具体实现。 ### 1. Android的SQLite数据库 SQLite是Android系统内置的关系型数据库，支持标准SQL语法，适用于轻...

    基于JDBC封装的BaseDao(实例代码).rar_java编程

    "基于JDBC封装的BaseDao实例"是一个常见的设计模式，用于简化数据库操作，提高代码复用性，降低耦合度。BaseDao通常作为基类，提供通用的数据库操作方法，比如增删查改（CRUD）等。 首先，我们需要了解JDBC的基本...

Magicbox
Global site tag (gtag.js) - Google Analytics