java web项目DAO层通用接口BaseDao与实现类BaseDaoImpl

在spring+hibernate的web项目中，处理数据层通常会使用Spring框架提供的HibernateTemplate类提供的方法。通常的用法是每一个实体类对应的去写DAO层的接口和实现类。每个实现类中都写hibernateTemp.save(entity)、hibernateTemp.update(entity)、hibernateTemp.get(id)...这样写固然没错，但存在着大量的重复代码。所以懒惰的程序员烦了，他们要写一个通用的实现类来解决这个问题，让DAO层解放出来。如果有特殊的需要则在实现类中写个方法去处理，没有特殊的需要那么我们就不用在写DAO层的代码了。

下面是我写的一个通用DAO层接口和实现类，初次写这种通用型的代码可能会有很多不到位的地方，如果您看到了，请在评论中不吝赐教，谢谢！

BaseDao.Java

package org.lxl.mr.common.base.db;

import java.util.List;
/**
 * 通用数据层接口
 * @author liuXueLiang
 * @param <Entity>
 * @param <PK>
 */
public interface BaseDao<Entity,PK> {
    /**
     * 增加
     * @param entity
     */
    public void save(Entity entity);
    /**
     * 修改
     * @param entity
     */
    public void update(Entity entity);
    /**
     * 删除
     * @param entity
     */
    public void delete(Entity entity);
    /**
     * 通过主键删除
     * @param pk
     * @param pkName
     */
    public void deleteByPK(final PK pk,final String pkName);
    /**
     * 通过主键查询
     * @param pk
     * @return
     */
    public Entity get(PK pk);
    /**
     * 通过主键查询，延迟加载
     * @param pk
     * @return
     */
    public Entity load(PK pk);
    /**
     * 查询全部
     * @return
     */
    public List<Entity> findAll();
    
}

BaseDaoImpl.java

package org.lxl.mr.common.base.db;

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

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.lxl.mr.common.page.Pagination;
import org.lxl.mr.common.util.ReflectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.Assert;
/**
 * 通用数数据层实现
 * @author liuXueLiang
 * @param <Entity>
 * @param <PK>
 */
public class BaseDaoImpl<Entity,PK extends Serializable> extends HibernateDaoSupport implements BaseDao<Entity, PK> {
    /**
     * 给HibernateDaoSupport中的hibernateTemplate赋值
     * @param sessionFactory
     */
    @Autowired
    public void setMySessionFactory(SessionFactory sessionFactory){
        super.setSessionFactory(sessionFactory);
    }
    
    /**
     * 子类的类对象
     */
    private Class<Entity> entityClass;
    
    /**
     * 创建对象时给entityClass赋值
     */
    protected BaseDaoImpl(){
        this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
    }

/**
     * 增加
     * @param entity
     */
    @Override
    public void save(Entity entity) {
        super.getHibernateTemplate().save(entity);
    }
    
    /**
     * 修改
     * @param entity
     */
    @Override
    public void update(Entity entity) {
        super.getHibernateTemplate().update(entity);
    }

/**
     * 通过主键删除    PK为主键的类型
     * @param pk 主键值
     * @param pkName主键名称（如：id、uuid）
     */
    @Override
    public void deleteByPK(final PK pk,final String pkName) {
        Integer executeCount = super.getHibernateTemplate().execute(new HibernateCallback<Integer>(){

@Override
            public Integer doInHibernate(Session session) throws HibernateException, SQLException {
                Assert.hasText(pkName);
                Assert.notNull(pk);
                String hql = "delete from "+entityClass.getName()+" where "+pkName+":=pk";
                Query query = session.createQuery(hql);
                if(pk instanceof java.lang.Integer){
                    query.setInteger("pk", (Integer) pk);
                }
                else if(pk instanceof java.lang.Long){
                    query.setLong("pk", (Long) pk);
                }
                else if(pk instanceof java.lang.String){
                    query.setString("pk", (String) pk);
                }
                else{
                    throw new RuntimeException("Does not support the type of the primary key! The primary key only support the type Integer,Long,String types. ");
                }
                return query.executeUpdate();
            }
            
        });
        
        if(executeCount!=1)
            throw new RuntimeException("Through the primary key to delete data failed");
    }
    /**
     * 删除
     * @param entity
     */
    @Override
    public void delete(Entity entity) {
        super.getHibernateTemplate().delete(entity);
    }
    
    /**
     * 通过主键查询    PK为主键类型
     * @param pk 主键值
     */
    @Override
    public Entity get(PK pk) {
        return super.getHibernateTemplate().get(entityClass, pk);
    }
    
    /**
     * 通过主键查询，延迟加载 PK为主键类型
     * @param pk 主键值
     */
    @Override
    public Entity load(PK pk) {
        return super.getHibernateTemplate().load(this.entityClass, pk);
    }
    
    /**
     * 查询全部
     * @return List<Entity>
     */
    @Override
    public List<Entity> findAll() {
        return this.findListByMap(null);
    }

/**
     * 根据条件查询唯一对象
     * @param map
     * @return Entity
     */
    public Entity findUnique(final Map<String,Object> map){
        return getHibernateTemplate().execute(new HibernateCallback<Entity>(){

@SuppressWarnings("unchecked")
            @Override
            public Entity doInHibernate(Session session) throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                if(map!=null){
                    criteria.add(Restrictions.allEq(map));    
                }
                return (Entity) criteria.uniqueResult();
            }
            
        });
    }
    /**
     * 根据条件查询
     * @param map
     * @return List<Entity>
     */
    @SuppressWarnings("unchecked")
    public List<Entity> findListByMap(final Map<String,Object> map){
        return (List<Entity>) getHibernateTemplate().execute(new HibernateCallback<Entity>(){

@Override
            public Entity doInHibernate(Session session) throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                if(map!=null){
                    criteria.add(Restrictions.allEq(map));    
                }
                return (Entity) criteria.list();
            }
        });
    }
    @SuppressWarnings("unchecked")
    public List<Entity> findListByDetachedCriteria(final DetachedCriteria detachedCriteria){
        return (List<Entity>) getHibernateTemplate().execute(new HibernateCallback<List<Entity>>(){

@Override
            public List<Entity> doInHibernate(Session session) throws HibernateException, SQLException {
                Criteria criteria = detachedCriteria.getExecutableCriteria(session);
                return (List<Entity>) criteria.list();
            }
            
        });
    }
    /**
     * 使用HQL语句查询唯一对象
     * @param hql
     * @param paramMap
     * @return    Entity
     */
    @SuppressWarnings("unchecked")
    public Entity findByHqlUnique(final String hql,final Map<String,Object> paramMap){
        Assert.hasText(hql);
        return (Entity) createHqlQuery(hql, paramMap).uniqueResult();
    }

/**
     * 使用HQL语句查询
     * @param hql
     * @param paramMap
     * @return List<Entity>
     */
    @SuppressWarnings("unchecked")
    public List<Entity> findByHQL(final String hql,final Map<String,Object> paramMap){
        Assert.hasText(hql);
        return createHqlQuery(hql, paramMap).list();
    }

/**
     * 使用SQL语句查询唯一对象
     * @param sql
     * @param paramMap
     * @return
     */
    public Object findBySQLUnique(final String sql,final Map<String,Object> paramMap){
        Assert.hasLength(sql);
        return createSqlQuery(sql, paramMap).uniqueResult();
    }
    /**
     * 使用SQL语句查询唯一对象
     * @param sql
     * @param paramMap
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> findBySQL(final String sql,final Map<String,Object> paramMap){
        Assert.hasText(sql);
        return (List<T>) createSqlQuery(sql, paramMap).list();
    } 
    /**
     * 批处理，使用HQL语句
     * @param hql
     * @param values
     * @return
     */
    public int execHQLBatchByMap(final String hql,final Map<String,Object> values){
        Assert.hasText(hql);
        return getHibernateTemplate().execute(new HibernateCallback<Integer>(){

@Override
            public Integer doInHibernate(Session session) throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                query.setProperties(values);
                return query.executeUpdate();
            }
            
        });
    }
    
    /**
     * 批处理，使用SQL语句
     * @param sql
     * @param values
     * @return
     */
    public int execSQLBatchByMap(final String sql,final Map<String,Object> values){
        Assert.hasText(sql);
        return getHibernateTemplate().execute(new HibernateCallback<Integer>(){

@Override
            public Integer doInHibernate(Session session) throws HibernateException, SQLException {
                Query query = session.createSQLQuery(sql);
                query.setProperties(values);
                return query.executeUpdate();
            }
            
        });
    }
    
    /**
     * HQL分页
     * @param hql
     * @param pageNo
     * @param pageSize
     * @param map
     * @return
     */
    @SuppressWarnings("rawtypes")
    public Pagination findPageByHql(final String hql,final int pageNo,final int pageSize,
            final Map<String,Object> map){
        Query query = createHqlQuery(hql, map);
        Pagination page = new Pagination();
        page.setPageSize(pageSize);
        page.setPageNo(pageNo);
        return this.pageResult(page, hql, null, query, map);
    }
    
    @SuppressWarnings("rawtypes")
    public Pagination findPageBySql(final String sql,int pageNo,int pageSize,
            final Map<String,Object> map){
        Query query = this.createSqlQuery(sql, map);
        Pagination page = new Pagination();
        page.setPageSize(pageSize);
        page.setPageNo(pageNo);
        return this.pageResult(page, null, sql, query, map);
    }
    
    @SuppressWarnings("rawtypes")
    private Pagination pageResult(final Pagination page,String hql,
            String sql,Query query,final Map<String,Object> map){
        Pagination pagination = page;
        Object obj = null;
        if(hql!=null && !"".equals(hql)){
            obj = createHqlQuery(hql, map).uniqueResult();
        }else if(sql!=null && !"".equals(sql)){
            obj = createSqlQuery(sql, map).uniqueResult();
        }else{
            return null;
        }
        int totalCount = Integer.parseInt(obj.toString());
        pagination.setTotalCount(totalCount);
        //查询列表，并保存到pagination对象中
        if(pagination.getPageSize()>0){
            query.setMaxResults(pagination.getPageSize());
            query.setFirstResult(pagination.getFirstResult());

}
        pagination.setList(query.list());
        return pagination;
    }
    
    
    
    /**
     * 创建Query对象，用来处理HQL查询
     * @param hql
     * @param paramMap
     * @return
     */
    protected Query createHqlQuery(final String hql,final Map<String,Object> paramMap){
        Assert.hasText(hql);
        return getHibernateTemplate().execute(new HibernateCallback<Query>(){
            @Override
            public Query doInHibernate(Session session) throws HibernateException, SQLException {
                if(session==null){
                    session = getSessionFactory().getCurrentSession();
                }
                Query query = session.createQuery(hql);
                query.setProperties(paramMap);
                return query;
            }
        });
    }
    
    /**
     * 创建Query对象，用来处理SQL查询
     * @param sql
     * @param paramMap
     * @return
     */
    protected Query createSqlQuery(final String sql,final Map<String,Object> paramMap){
        Assert.hasText(sql);
        return getHibernateTemplate().execute(new HibernateCallback<Query>(){
            @Override
            public Query doInHibernate(Session session) throws HibernateException, SQLException {
                Query query = session.createSQLQuery(sql);
                query.setProperties(paramMap);
                return query;
            }
        });
        
    }
}

使用
UserDao.java

package org.lxl.mr.dao;

import org.lxl.mr.common.base.db.BaseDao;
import org.lxl.mr.pojo.User;

public interface UserDao extends BaseDao<User, String>{
    
}

UserDaoImpl.java

package org.lxl.mr.dao.impl;

import org.lxl.mr.common.base.db.BaseDaoImpl;
import org.lxl.mr.dao.UserDao;
import org.lxl.mr.pojo.User;
import org.springframework.stereotype.Component;
@Component
public class UserDaoImpl extends BaseDaoImpl<User, String> implements UserDao {
    
}

时间： 2024-08-08 22:04:35

java web项目DAO层通用接口BaseDao与实现类BaseDaoImpl的相关文章

java Web项目Service层通用接口和entityVo对象与entity对象转化问题的解决方案

Service层的接口中有一些比较常用方法,一次又一次的在新的Service层中被书写,所以懒惰的程序员又烦了,他们决定写个通用接口来解决这个问题. 有些项目中,实体类即承担接收表单数据的任务,又承担持久化任务,很省心.但有些项目中这两项任务的执行类不是同一个,一个Entity.java来执行数据 持久化的任务,一个EntityVo.java类来执行接收表单数据的任务.那么问题来了:Service层需要的是entityVo对象,而DAO层需要的是entity对象,这两个对象 会有一些相同的属性和

java web项目war包部署，使用tomcat对指定接口设置身份认证

先简单说一下需求: 将一个基于springboot2.0开发的java web项目打成war包,通过tomcat部署到一台linux服务器上,项目相关的一些图片等资源也按照一定规则放置在服务器构建好的目录下.现在需要让用户通过http网页链接的方式(在浏览器端)访问图片,为了访问安全,需要在中间加一层用户认证.认证过程希望尽量简单些,所以就尝试用tomcat自带的身份认证来做. 话不多说,直接上实现流程: 首先,由于要访问本地的静态资源,所以在springboot启动类中加了一项静态资源的映射,

大型Java Web项目的架构和部署问题

一位ID是jackson1225的网友在javaeye询问了一个大型Web系统的架构和部署选型问题,希望能提高现有的基于Java的Web应用的服务能力.由于架构模式和部署调优一直是Java社区的热门话题,这个问题引发了很多热心网友的讨论,其中一些意见对其它大型Web项目也有很好的指导意义.在讨论之初jackson1225这样描述了当前的应用的架构和部署方案: 目前系统架构如下: web层采用struts+tomcat实现,整个系统采用20多台web服务器,其负载均衡采用硬件F5来实现; 中间层采

熟悉基于JSP和Servlet的Java Web开发，对Servlet和JSP的工作原理和生命周期有深入了解，熟练的使用JSTL和EL编写无脚本动态页面，有使用监听器、过滤器等Web组件以及MVC架构模式进行Java Web项目开发的经验。

熟悉基于JSP和Servlet的Java Web开发,对Servlet和JSP的工作原理和生命周期有深入了解,熟练的使用JSTL和EL编写无脚本动态页面,有使用监听器.过滤器等Web组件以及MVC架构模式进行Java Web项目开发的经验. 1.说一说Servlet生命周期(非常重要) Servlet生命周期包括三部分: 初始化:Web容器加载servlet,调用init()方法 只执行一次 处理请求:当请求到达时,运行其service()方法.service()自动调用与请求相对应的doXXX

Java web项目的解耦合

以前的项目大多数都是java程序猿又当爹又当妈,又搞前端(ajax/jquery/js/html/css等等),又搞后端(java/mysql/oracle等等). 随着时代的发展,渐渐的许多大中小公司开始把前后端的界限分的越来越明确,前端工程师只管前端的事情,后端工程师只管后端的事情,正所谓术业有专攻,一个人如果什么都会,那么他毕竟什么都不精. 大中型公司需要专业人才,小公司需要全才,但是对于个人职业发展来说,我建议是分开.你要是这辈子就吃java这碗饭,就不要去研究什么css,js等等. 把

做一个完整的Java Web项目需要掌握的技能

原文链接:http://blog.csdn.net/JasonLiuLJX/article/details/51494048 最近自己做了几个Java Web项目,有公司的商业项目,也有个人做着玩的小项目,写篇文章记录总结一下收获,列举出在做项目的整个过程中,所需要用到的技能和知识点,带给还没有真正接触过完整Java Web项目的同学一个比较完整的视角,提供一个所谓的"大局观",也以便于同学们更有针对性地学习.当然,这里所用到的例子项目是非常初级,简单的项目,所以大神们就可以不用往下看

MVC模式下基于SSH三大框架的java web项目excel表格的导出(不依赖另外的jar包)

最近工作中碰到了需要将web页面的表格内容导出到excel表格并下载到本地的需求.以下是在利用网上资源.与同事探讨下,完成的代码. 首先我们需要有定义好的实体类.以下是截取了项目中用到的部分代码. 1 public class QyggDocuments implements java.io.Serializable { 2 3 private static final long serialVersionUID = -2543382529255041149L; 4 5 private Stri

做一个完整的Java Web项目需要掌握的技能[转]

转自:http://blog.csdn.net/JasonLiuLJX/article/details/51494048 最近自己做了几个Java Web项目,有公司的商业项目,也有个人做着玩的小项目,写篇文章记录总结一下收获,列举出在做项目的整个过程中,所需要用到的技能和知识点,带给还没有真正接触过完整Java Web项目的同学一个比较完整的视角,提供一个所谓的"大局观",也以便于同学们更有针对性地学习.当然,这里所用到的例子项目是非常初级,简单的项目,所以大神们就可以不用往下看了.

java web项目答辩答辩题总结

答辩每个人的总分为1.5分.每个人主要问3个问题. 开发流程===>系统架构====>项目模块+功能===>项目得失重定向与转发:?九个隐式对象?get与post的区辨:?jsp有静态包含,动态包含,两者的区辨:?什么是MVC:?web系统架构:? java web项目答辩 1 http协议全名和特点 ------------------------------------------------------ HTTP是一种超文本传输协议(HyperText Transfer Proto