hibernate基础dao类

功能：数据库的保存、更新、删除；sql、hql查询；分页查询；调用存储过程

创建hibernate基础dao类：

　　BaseDao.java

package com.ims.persistence.base;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.hibernate.criterion.DetachedCriteria;

/**
 * 统一数据访问接口
 */
public interface BaseDao<T extends Serializable> {

    /**
     * 保存实体对象
     * @param entity 实体对象
     */
    public void save(T entity); 

    /**
     * 更新实体对象
     * @param 实体对象
     */
    public void update(T entity);

    /**
     * 保存或更新实体对象
     * @param entity 实体对象
     */
    public void saveOrUpdate(T entity);

    /**
     * 删除实体对象
     * @param entity 实体对象
     */
    public void delete(T entity);

    /**
     * 查询hql语句，返回唯一结果
     * @param hql
     */
    public Object findUniqueResult(String hql); 

    /**
     * 执行sql语句，更新数据库
     * @param sql
     */
    public void updateBySql(String sql);

    /**
     * 通过Criteria对象查询，返回实体对象结果集
     * @param detachedCriteria 离线的Criteria对象
     * @return 实体对象结果集
     */
    public List findByCriteria(DetachedCriteria detachedCriteria);

    /**
     * 通过sql语句查询，返回map对象结果集
     * @param sql
     * @return map对象结果集
     */
    public List<Map<String, Object>> findBySql(String sql);

    /**
     * 查询sql语句，返回唯一结果
     * @param sql
     */
    public Object findUniqueResultBySql(String sql);

    /**
     * 通过Criteria对象查询，返回结果集的记录数
     * @param detachedCriteria 离线的Criteria对象
     * @return 结果集的记录数
     */
    public long getCount(DetachedCriteria detachedCriteria);

    /**
     * 通过Criteria对象进行分页查询，返回实体对象结果集
     * @param pageNum 第几页
     * @param pageSize 每页大小
     * @param detachedCriteria 离线的Criteria对象
     * @return 实体对象结果集
     */
    public List<T> findPage(int pageNum, int pageSize, DetachedCriteria detachedCriteria);

    /**
     * 通过sql语句，进行分页查询，返回分页对象
     * @param pageNum 第几页
     * @param pageSize 每页大小
     * @param sql
     * @return 分页对象
     */
    public Pagination findPage(int pageNum, int pageSize, String sql); // 查找分页对象列表

    /**
     * 调用存储过程，返回单结果集
     * @param proceName 存储过程名称
     * @param params 输入参数集合
     * @return map对象结果集
     */
    public List<Map<String, Object>> callProcedure(String proceName, final List<Object> params);
}

　　BaseDaoImpl.java

package com.ims.persistence.base;

import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.hibernate.jdbc.Work;

public class BaseDaoImpl<T extends Serializable> implements BaseDao<T>{          

    private SessionFactory sessionFactory;

    public BaseDaoImpl(){
        super();
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    /**
     * 返回数据库session对象
     * @return
     */
    protected Session getSession(){
        return sessionFactory.getCurrentSession();
    }

    /**
     * 保存实体对象
     * @param entity 实体对象
     */
    @Override
    public void save(T entity){
        Session session = getSession();
        session.save(entity);
        session.flush();
        session.evict(entity);
    }

    /**
     * 更新实体对象
     * @param 实体对象
     */
    @Override
    public void update(T entity){
        Session session = getSession();
        session.update(entity);
        session.flush();
        session.evict(entity);
    }

    /**
     * 保存或更新实体对象
     * @param entity 实体对象
     */
    @Override
    public void saveOrUpdate(T entity) {
        Session session = getSession();
        session.saveOrUpdate(entity);
        session.flush();
        session.evict(entity);
    }

    /**
     * 删除实体对象
     * @param entity 实体对象
     */
    @Override
    public void delete(T entity){
        Session session = getSession();
        session.delete(entity);
        session.flush();
        session.evict(entity);
    }    

    /**
     * 查询hql语句，返回唯一结果
     * @param hql
     */
    @Override
    public Object findUniqueResult(String hql){
        Query query = getSession().createQuery(hql);
        return query.uniqueResult();
    }

    /**
     * 执行sql语句，更新数据库
     * @param sql
     */
    @Override
    public void updateBySql(final String sql){
        getSession().doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                connection.prepareStatement(sql).executeUpdate();
            }
        });
    }    

    /**
     * 通过Criteria对象查询，返回实体对象结果集
     * @param detachedCriteria 离线的Criteria对象
     * @return 实体对象结果集
     */
    @Override
    public List findByCriteria(DetachedCriteria detachedCriteria){
        Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
        List records = criteria.list();
        return records;
    }

    /**
     * 通过sql语句查询，返回map对象结果集
     * @param sql
     * @return map对象结果集
     */
    @Override
    public List<Map<String, Object>> findBySql(final String sql){
        final List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        getSession().doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                ResultSet rs = connection.prepareStatement(sql).executeQuery();
                result.addAll(RsHelper.rSToList(rs));
            }
        });
        return result;
    }

    /**
     * 查询sql语句，返回唯一结果
     * @param sql
     */
    @Override
    public Object findUniqueResultBySql(String sql) {
        return getSession().createSQLQuery(sql.toString()).uniqueResult();
    }

    /**
     * 通过Criteria对象查询，返回结果集的记录数
     * @param detachedCriteria 离线的Criteria对象
     * @return 结果集的记录数
     */
    @Override
    public long getCount(DetachedCriteria detachedCriteria) {
        Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
        Object object = criteria.setProjection(Projections.rowCount()).uniqueResult();
        criteria.setProjection(null);
        Long totalRow = Long.valueOf(String.valueOf(object));
        return totalRow;
    }

    /**
     * 通过Criteria对象进行分页查询，返回实体对象结果集
     * @param pageNum 第几页
     * @param pageSize 每页大小
     * @param detachedCriteria 离线的Criteria对象
     * @return 实体对象结果集
     */
    @Override
    public List<T> findPage(int pageNum, int pageSize,
            DetachedCriteria detachedCriteria){
        Criteria criteria = detachedCriteria.getExecutableCriteria(getSession());
        List<T> records = criteria.setFirstResult((pageNum-1) * pageSize).setMaxResults(pageSize).list();
        return records;
    }

    /**
     * 通过sql语句，进行分页查询，返回分页对象
     * @param pageNum 第几页
     * @param pageSize 每页大小
     * @param sql
     * @return 分页对象
     */
    @Override
    public Pagination findPage(final int pageNum, final int pageSize,final String sql){
        final Pagination page = new Pagination();
        getSession().doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                String countSql = MessageFormat.format("select count(*) from ({0}) page", sql);
                ResultSet rs = connection.prepareStatement(countSql).executeQuery();
                page.setTotal(Long.valueOf(RsHelper.getUniqueResult(rs).toString()));

                long firstResult = (pageNum - 1)*pageSize;
                String selectSql = MessageFormat.format("select * from ({0}) page limit {1},{2}", sql, firstResult, firstResult+pageSize);
                page.setRows(RsHelper.rSToList(connection.prepareStatement(selectSql).executeQuery()));
            }
        });

        return page;
    }

    /**
     * 调用存储过程，返回单结果集
     * @param proceName 存储过程名称
     * @param params 输入参数集合
     * @return map对象结果集
     */
    public List<Map<String, Object>> callProcedure(String proceName, final List<Object> params){
        final List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        final StringBuffer sql = new StringBuffer();
        sql.append("{call " + proceName + "(");
        for(int i=0; params!=null && i<params.size(); i++){
            sql.append("?");
            if(i+1!=params.size())
                sql.append(",");
        }
        sql.append(")}");
        getSession().doWork(new Work() {
            @Override
            public void execute(Connection connection) throws SQLException {
                CallableStatement statement = connection.prepareCall(
                        sql.toString());
                for(int i=0; i<params.size(); i++){
                    statement.setObject(i+1, params.get(i));//设置参数
                }

                result.addAll(RsHelper.rSToList(statement.executeQuery()));
            }
        });

        return result;
    }

}

　　Pagination.java

package com.ims.persistence.base;

import java.util.ArrayList;
import java.util.List;

/**
 * 分页对象，一般用于响应页面请求
 */
public class Pagination {
    /**
     * 总记录数
     */
    private Long total = 0l;

    /**
     * 记录集合
     */
    private List rows = new ArrayList();

    public Long getTotal() {
        return total;
    }
    public void setTotal(Long total) {
        this.total = total;
    }    

    public List getRows() {
        return rows;
    }
    public void setRows(List rows) {
        this.rows = rows;
    }
}

　　RsHelper.java

package com.ims.persistence.base;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 数据库结果集帮助器
 */
public class RsHelper {
    /**
     * 返回结果集中的唯一结果，没有则返回null
     * @param rs 结果集
     * @return
     * @throws SQLException
     */
    public static Object getUniqueResult(ResultSet rs) throws SQLException{
        if(rs.next()) {
            return rs.getObject(1);
        }
        return null;
    }

    /**
     * 将实体结果集对象转换为map对象结果集
     * @param rs 实体结果集对象
     * @return map对象结果集
     * @throws SQLException
     */
    public static List<Map<String,Object>> rSToList(ResultSet rs) throws SQLException {
        if (rs == null)
            return Collections.EMPTY_LIST;
        ResultSetMetaData md = rs.getMetaData(); //得到结果集(rs)的结构信息，比如字段数、字段名等
        int columnCount = md.getColumnCount(); //返回此 ResultSet 对象中的列数
        List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
        Map<String,Object> rowData = new HashMap<String,Object>();
        while (rs.next()) {
            rowData = new HashMap<String,Object>(columnCount);
            for (int i = 1; i <= columnCount; i++) {
                rowData.put(md.getColumnName(i), rs.getObject(i));
            }
            list.add(rowData);
        }
        return list;
    }
}

hibernate基础dao类的更多相关文章

Hibernate.基础篇《一》.Hibernate工具类.
Hibernate.基础篇<一>.Hibernate工具类. 话述: Hibernate.基础篇第一篇,前面是代码.后面再加理论&实践. Hibernate使用的版本是:5.x,在 ...
SSH框架整合中Hibernate实现Dao层常用结构
一.疑惑一直以来,我在使用SSH框架的时候经常会发现后者有疑虑到底使用hibernate的那种方法或者如何配置hibernate来操作数据库,经过一段时间的学习下面我来总结一下,常用的dao层配置 ...
springMVC基础controller类
此文章是基于搭建SpringMVC+Spring+Hibernate平台功能:设置请求.响应对象:session.cookie操作:ajax访问返回json数据: 创建springMVC基础con ...
[Hibernate] - Generic Dao
使用泛型写了一个通用的Hibernate DAO类. GenericDao接口 package com.my.dao; import java.io.Serializable; import java ...
hibernate基础（1）
hibernate基础1.hibernate介绍与动手入门体验问题:模型不匹配(java对象模型与数据库关系模型不匹配) 解决: 1.使用JDBC手工转换 2.使用ORM(Obje ...
《项目架构那点儿事》——Hibernate泛型Dao，让持久层简洁起来
[前言]hibernate作为持久层ORM技术,它对JDBC进行非常轻量级对象封装,使得我们可以随心所欲的使用面向对象的思想来操作数据库.同时,作为后台开发的支撑,的确扮演了一个举足轻重的角色,那么 ...
Hibernate 基础解析（Configuration，SessionFactory，Session，Transaction，Query，Criteria）
1 框架体系结构对象关系映射(英语:(Object Relational Mapping,简称ORM,或O/RM,或O/R mapping),是一种程序技术,用于实现面向对象编程语言里 ...
mybatis的基础Dao
话不多说,直接贴代码吧,因为很多博客都需要用到这个基础dao,怕大家不好查询. 这个基类主要是使用了泛型,这样我就不必为每一个实体都写一个dao,大大节省了时间.其中sqlSessionTemplat ...
Hibernate.基础篇《二》. getOpenSession() 和 getCurrentSession() - 1
Hibernate.基础篇<二>. getOpenSession() 和 getCurrentSession() - 1 说明: 在Hibernate应用中,Session接口的使用最为广 ...

随机推荐

MongoDB-基础-条件操作符
1.一些解释 less than : 比..少 lt greater than : 比..多 gt equals :相等 e ...
你必须知道ASP.NET知识------关于动态注册httpmodule(对不起汤姆大叔)
一.关于动态注册的问题很多人看过汤姆大叔的MVC之前的那点事儿系列(6):动态注册HttpModule ,其实汤姆大叔没有发现httpmodule动态注册的根本机制在哪里. 亦即:怎么动态注册?为什 ...
基于OpenSLL的RSA加密应用(非算法)
基于OpenSLL的RSA加密应用(非算法) iOS开发中的小伙伴应该是经常用der和p12进行加密解密,而且在通常加密不止一种加密算法,还可以加点儿盐吧~本文章主要阐述的是在iOS中基于openSL ...
html5 postMessage解决iframe跨协议跨域通信问题
a.html有个iframe载入b.com/login.html,当login完成时通知a.html页面登录完成并传递UserName 1.a.html 监听消息 window.addEventLis ...
批量导出access某表内容到word文档
一.需求: 需要将表中每一条记录中的某些内容导出在一个word文档中,并将这些文档保存在指定文件夹目录下二.界面,简单设计如下: 三.添加office相关引用添加后可在解决方案资源管理器中看到: ...
Hadoop JAVA 开发说明
作为Hadoop程序员,他要做的事情就是: 1.定义Mapper,处理输入的Key-Value对,输出中间结果.2.定义Reducer,可选,对中间结果进行规约,输出最终结果.3.定义InputFor ...
java.lang.IllegalArgumentException: Illegal character in query at index 261
在BaseFragment中使用了LoadingPage,而LoadingPage的联网加载使用的是AsyncHttpClient.一直报java.lang.IllegalArgumentExcept ...
ABP 初探之基于EasyUI的CURD
结束了天天加班的项目,项目虽然结束,但还是有点小问题,只能在后期优化当中完成了,本次做项目采用了,MVC.Webapi.Entityframework,在园了里看到了有关ABP的介绍,同样ABP也是最 ...
浅谈网站web框架的本质
一.web框架的本质众所周知,对于所有的Web应用,本质上其实就是一个socket服务端,用户的浏览器其实就是一个socket客户端. import socket def handle_reques ...
iOS适配旧项目工程在iOS9下不能正常显示
在iOS开发中,很多时候会用到旧项目,比如版本的升级.使用Demo等等, iOS SDK正在不断的升级,不断的升级给iOS开发带来了新的活力. 然而在iOS SDK新的版本出来之后,旧项目可能会出现新 ...

hibernate基础dao类

hibernate基础dao类的更多相关文章

随机推荐

热门专题