设计的非常非常好用的DAO(哈)

最新推荐文章于 2024-05-28 17:17:39 发布
最新推荐文章于 2024-05-28 17:17:39 发布
阅读量113 收藏
点赞数
分类专栏： java 文章标签： DAO SQL Java Apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackson_jar/article/details/83286502
版权

 收集下来，方便自己，也方便大家！


package com.scitel.gdnumcommon.utils;  
 
import java.math.BigDecimal;  
import java.sql.Connection;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.Types;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
 
import org.apache.commons.beanutils.BeanUtils;  
import org.apache.commons.logging.Log;  
import org.apache.commons.logging.LogFactory;  
 
import com.scitel.gdnumcommon.entity.Pagination;  
import com.scitel.gdnumcommon.entity.BaseVO;  
 
public class BaseDAO {  
    private static final Log log = LogFactory.getLog(BaseDAO.class);  
 
    /** 
     * 保存数据,新建和修改都用这个 
     * 
     * @param con 
     * @param SQL 
     * @param params 
     * @throws Exception 
     * @author  
     */ 
    public void save(Connection con, String SQL, List params)  
            throws Exception {  
        PreparedStatement ps = null;  
        try {  
            ps = con.prepareStatement(SQL);  
            if (SQL == null) {  
                throw new Exception();  
            }  
 
            if (params != null && params.size() > 0) {  
                int count = 0;  
                for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {  
                    Object object = iterator.next();  
                    setObjectValue(ps, count + 1, object);  
                }  
            }  
            ps.executeUpdate();  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try{  
                if(ps != null) {  
                    ps.close();  
                }  
            }catch(Exception e){  
 
            }  
        }  
    }  
 
    /** 
     * 保存数据,新建和修改都用这个,通过字段名称匹配类型 
     * @param con 
     * @param SQL 
     * @param voclass 
     * @param paramMap 
     * @throws Exception 
     * @author  
     */ 
    public void save(Connection con, String SQL, Class voclass, Map paramMap)  
            throws Exception {  
        PreparedStatement ps = null;  
        try {  
            ps = con.prepareStatement(SQL);  
            if (SQL == null) {  
                throw new Exception();  
            }  
 
            if (paramMap != null && paramMap.size() > 0) {  
                int count = 0;  
                for (Iterator iterator = paramMap.keySet().iterator(); iterator.hasNext(); count++) {  
 
                    String key = (String)iterator.next();  
                    Object object = paramMap.get(key);  
                    setObjectValue(ps, voclass, count+1, key, object);  
                }  
            }  
            ps.executeUpdate();  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try{  
                if(ps != null) {  
                    ps.close();  
                }  
            }catch(Exception e){  
 
            }  
        }  
    }  
 
    /** 
     * 删除数据 
     * 
     * @param con 
     * @param SQL 
     * @param params 
     * @throws Exception 
     * @author  
     */ 
    public void remove(Connection con, String SQL, List params)  
            throws Exception {  
        PreparedStatement ps = null;  
        try {  
            ps = con.prepareStatement(SQL);  
            if (SQL == null) {  
                throw new Exception();  
            }  
            if (params != null && params.size() > 0) {  
                int count = 0;  
                for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {  
                    Object object = iterator.next();  
                    setObjectValue(ps, count + 1, object);  
                }  
            }  
            ps.executeUpdate();  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try{  
                if(ps != null) {  
                    ps.close();  
                }  
            }catch(Exception e){  
 
            }  
        }  
    }  
 
    /** 
     * 根据ID选择数据 
     * 
     * @param con 
     * @param SQL 
     * @param id 
     * @param voclass 
     * @return 
     * @throws Exception 
     * @author  
     */ 
    public BaseVO selectById(Connection con, String SQL, String id,  
            Class voclass) throws Exception {  
        Object po = null; // 承载值对象  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
        ResultSetMetaData rsm = null;  
        try {  
            ps = con.prepareStatement(SQL);  
            if (SQL == null) {  
                throw new Exception();  
            }  
 
            ps.setString(1, id);  
 
            rs = ps.executeQuery();  
            rsm = rs.getMetaData();  
            if (rs.next()) {  
                Map entity = new HashMap();  
                for (int i = 1; i <= rsm.getColumnCount(); i++) {  
                    String columnName = rsm.getColumnName(i).toLowerCase();  
                    Object columnValue = getObjectValue(rs, voclass, i, columnName);  
                    entity.put(columnName, columnValue);  
                }  
                if (voclass != null) {  
                    po = voclass.newInstance();  
                    BeanUtils.populate(po, entity);  
                }  
                   
            }  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try {  
                if (rs != null) {  
                    rs.close();  
                }  
            } catch (Exception e) {  
 
            }  
            try {  
                if (ps != null) {  
                    ps.close();  
                }  
            } catch (Exception e) {  
 
            }  
        }  
        return (BaseVO) po;  
    }  
 
    /** 
     * 选择记录,不分页 
     * @param con 
     * @param SQL 
     * @param params 
     * @param voclass 
     * @return 
     * @throws Exception 
     * @author  
     */ 
    public List select(Connection con, String SQL, List params, Class voclass)  
            throws Exception {  
        Object vo = null; // 承载值对象  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
        ResultSetMetaData rsm = null;  
        List relist = null;  
        try {  
            ps = con.prepareStatement(SQL);  
            if (SQL == null) {  
                throw new Exception();  
            }  
            if (params != null && params.size() > 0) {  
                int count = 0;  
                for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {  
                    Object object = iterator.next();  
                    setObjectValue(ps, count + 1, object);  
                }  
            }  
            rs = ps.executeQuery();  
            rsm = rs.getMetaData();  
            relist = new ArrayList();  
            while (rs.next()) {  
                Map entity = new HashMap();  
                for (int i = 1; i <= rsm.getColumnCount(); i++) {  
                    String columnName = rsm.getColumnName(i).toLowerCase();  
                    Object columnValue = getObjectValue(rs, voclass, i, columnName);  
                    entity.put(columnName, columnValue);  
                      
                }  
                if (voclass != null) {  
                    vo = voclass.newInstance();  
                    BeanUtils.populate(vo, entity);  
                    relist.add(vo);  
                } else {  
                    relist.add(entity);  
                }  
            }  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try {  
                if (rs != null) {  
                    rs.close();  
                }  
            } catch (Exception e) {  
 
            }  
            try {  
                if (ps != null) {  
                    ps.close();  
                }  
            } catch (Exception e) {  
 
            }  
              
        }  
        return relist;  
    }  
 
    /** 
     * 分页查询 
     * 
     * @param con 
     * @param SQL 
     * @param params 
     * @param voclass 
     * @param pagination 
     * @return 
     * @throws Exception 
     * @author  
     */ 
    public List selectPagination(Connection con, String SQL, List params,  
            Class voclass, Pagination pagination) throws Exception {  
        if (SQL == null) {  
            throw new NullPointerException("SQL不能为空!");  
        }  
        if (pagination == null) {  
            throw new NullPointerException("分页类不能为空!");  
        }  
 
        // TODO Auto-generated method stub  
        Object vo = null; // 承载值对象  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
        ResultSetMetaData rsm = null;  
        List relist = null;  
        try {  
 
            ps = con.prepareStatement("select count(1) as count_ from ( " + SQL + " )");  
 
            if (params != null && params.size() > 0) {  
                int count = 0;  
                for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {  
                    Object object = iterator.next();  
                    setObjectValue(ps, count + 1, object);  
                }  
            }  
 
            rs = ps.executeQuery();  
            if (rs.next()) {  
                pagination.setTotalCount(rs.getInt(1));  
                  
            }  
              
 
            if (pagination.getTotalCount() > 0) {  
                /* 组成分页内容 */ 
                StringBuffer pagingSelect = new StringBuffer(100);  
                pagingSelect  
                        .append("select * from ( select row_.*, rownum rownum_ from ( ");  
                pagingSelect.append(SQL);  
                pagingSelect  
                        .append(" ) row_ where rownum <= ?) where rownum_ > ?");  
 
                ps = con.prepareStatement(pagingSelect.toString());  
                int count = 0;  
                if (params != null && params.size() > 0) {  
                    for (Iterator iterator = params.iterator(); iterator.hasNext(); count++) {  
                        Object object = iterator.next();  
                        setObjectValue(ps, count + 1, object);  
                    }  
                }  
                  
                ps.setInt(count + 1, pagination.getPage()  
                        * pagination.getCount());  
                ps.setInt(count + 2, (pagination.getPage() - 1)  
                        * pagination.getCount());  
 
                log.info("pagination.getPage():" + pagination.getPage());  
                log.info("pagination.getCount():" + pagination.getCount());  
                rs = ps.executeQuery();  
                rsm = rs.getMetaData();  
                relist = new ArrayList();  
                while (rs.next()) {  
                    Map entity = new HashMap();  
                    for (int i = 1; i <= rsm.getColumnCount(); i++) {  
                        String columnName = rsm.getColumnName(i).toLowerCase();  
                        Object columnValue = getObjectValue(rs, voclass, i, columnName);  
                        entity.put(columnName, columnValue);  
                    }  
                    if (voclass != null) {  
                        vo = voclass.newInstance();  
                        BeanUtils.populate(vo, entity);  
                        relist.add(vo);  
                    } else {  
                        relist.add(entity);  
                    }  
                }  
            }  
        } catch (Exception e) {  
            log.error(e);  
            throw e;  
        } finally {  
            try {  
                if (rs != null) {  
                    rs.close();  
                }  
            } catch (Exception e) {  
 
            }  
            try {  
                if (ps != null) {  
                    ps.close();  
                }  
            } catch (Exception e) {  
 
            }  
 
        }  
        return relist;  
    }  
 
    /** 
     * 获得SequenceValue 
     * @param sequenceName 
     * @return 
     * @throws Exception 
     * @author  
     */ 
    public Long getSequenceValue(Connection con, String sequenceName)throws Exception {  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
        Long sequenceValue = null;  
        try{  
            ps = con.prepareStatement("select " + sequenceName + ".nextval from dual");  
            rs = ps.executeQuery();  
            if(rs.next()) {  
                sequenceValue = new Long(rs.getLong(1));  
            }  
        }catch(Exception e){  
            log.error(e);  
            throw e;  
        }finally{  
            try {  
                if (rs != null) {  
                    rs.close();  
                }  
            } catch (Exception e) {  
 
            }  
            try {  
                if (ps != null) {  
                    ps.close();  
                }  
            } catch (Exception e) {  
 
            }  
        }  
        return sequenceValue;  
    }  
    /** 
     * 把对象传入数据库 
     * @param ps 
     * @param count 
     * @param object 
     * @author  
     */ 
    private final void setObjectValue(PreparedStatement ps, int count, Object object) throws Exception {  
        log.debug("count is " + count + " object is " + object);  
        if(object != null) {  
            if(object instanceof Integer){  
                ps.setInt(count, ((Integer)object).intValue());  
            }else if(object instanceof Long) {  
                ps.setLong(count, ((Long)object).longValue());  
            }else if(object instanceof BigDecimal){  
                ps.setBigDecimal(count, (BigDecimal)object);  
            }else if(object instanceof String){  
                ps.setString(count, (String)object);  
            }else if(object instanceof java.util.Date) {  
                if(object!=null){  
                    long time = ((java.util.Date)object).getTime();  
                    ps.setDate(count, new java.sql.Date(time));  
                }else{  
                    ps.setDate(count, null);  
                }  
            }else{  
                ps.setObject(count, object);  
            }  
        }else{  
            ps.setNull(count, Types.INTEGER);  
        }  
    }  
 
    /** 
     * 把对象传入数据库 
     * @param ps 
     * @param clazz 
     * @param count 
     * @param columnName 
     * @param object 
     * @throws Exception 
     * @author  
     */ 
    private final void setObjectValue(PreparedStatement ps, Class clazz, int count,  
            String columnName, Object object)throws Exception {  
        log.debug("count is " + count + " columnName is " + columnName + " object is " + object);  
        String classType = clazz.getDeclaredField(columnName).getType().getName();  
        if(classType.equals("java.lang.Integer")){  
            if(object != null) {  
                ps.setInt(count, ((Integer)object).intValue());  
            }else{  
                ps.setNull(count, Types.INTEGER);  
            }  
        }else if(classType.equals("java.lang.Long")) {  
            if(object != null ) {  
                ps.setLong(count, ((Long)object).longValue());  
            }else{  
                ps.setNull(count, Types.INTEGER);  
            }  
        }else if(classType.equals("java.math.BigDecimal")){  
            if(object != null) {  
                ps.setBigDecimal(count, (BigDecimal)object);  
            }else{  
                ps.setNull(count, Types.NUMERIC);  
            }  
        }else if(classType.equals("java.lang.String")){  
            if(object != null) {  
                ps.setString(count, (String)object);  
            }else{  
                ps.setString(count, null);  
            }  
        }else if(classType.equals("java.util.Date")) {  
            if(object!=null){  
                long time = ((java.util.Date)object).getTime();  
                ps.setDate(count, new java.sql.Date(time));  
            }else{  
                ps.setDate(count, null);  
            }  
        }else{  
            ps.setObject(count, object);  
        }  
    }  
 
    /** 
     * 把数据从数据取出来 
     * @param rs 
     * @param clazz 
     * @param count 
     * @param columnName 
     * @return 
     * @throws Exception 
     * @author  
     */ 
    private final Object getObjectValue(ResultSet rs, Class clazz, int count, String columnName) throws Exception {  
        Object fieldValue = null;  
        log.debug("columnName is " + columnName + " count is " + count);  
        if(columnName != null) {  
            if("rownum".equals(columnName)) {  
                fieldValue = new Long(rs.getLong(count));  
            }else if("rownum_".equals(columnName)) {  
                fieldValue = new Long(rs.getLong(count));  
            }else if("count_".equals(columnName)) {  
                fieldValue = new Long(rs.getLong(count));  
            }else{  
                String classType = clazz.getDeclaredField(columnName).getType().getName();  
 
                if(classType.equals("java.lang.Integer")){  
                    fieldValue =new Integer( rs.getInt(count));  
                }else if(classType.equals("java.lang.Long")) {  
                    fieldValue =new Long( rs.getLong(count));  
                }else if(classType.equals("java.math.BigDecimal")){  
                    fieldValue = rs.getBigDecimal(count);  
                }else if(classType.equals("java.lang.String")){  
                    fieldValue = rs.getString(count);  
                }else if(classType.equals("java.util.Date")) {  
                    java.sql.Date date = rs.getDate(count);  
                    if(date!= null){  
                        fieldValue = new java.util.Date(date.getTime());  
                    }  
                }else{  
                    fieldValue = rs.getString(count);  
                }  
            }  
        }  
        return fieldValue;  
    }  
 
 
} 

 

有什么更好的意见，可以发到这里来交流，欢迎！！

可乐_
关注
专栏目录
关于dao层的设计与思考
qq_54731910的博客
07-07 1200
dao层简介 dao-Data Access Objects又叫做数据访问对象，主要是做数据持久层的工作，简单点来说就是负责对数据进行增删改查。一般来说实现dao之前需要定义dao的接口，然后实现接口。在实际开发中，一般来讲一个model对应一个dao。例如存在user代表用户信息，用户信息保存在数据库中，为了对用户信息进行一些操作需要实现userDao，来完成对用户信息的增删改查操作。 如何设计dao层 在实际的需求中，假设有如下需求，以mysql的查询为例，某个表中存在A，B，C，D四个字段，
《数据库课程设计》报告（代码+截图+报告）附源码资源包
upc_ws云边牧风是文森
09-23 1141
使用课程所学的编程语言（C#或Java等）和MySQL编写代码实现设计的数据库应用系统（B/S结构）
DAO设计模式的介绍与实现
热门推荐
wd
11-10 1万+
前言：哈哈，第一篇关于Java的博客了，暑假看了一些Java的设计模式，本来想着总结一下的，但是一耽误就到现在了，后面慢慢补上。今天我们来聊聊DAO 1、DAO是个什么东西呢? 看一下官方的介绍，DAO（Data Access Object，数据访问对象）的主要功能是数据操作，在程序的标准开发架构中属于数据层的操作。额，好像有点糊涂啊，用人类的语言解释一下也就是DAO是一种操作数据库的设计
java mysql dao_Java DAO 模式
weixin_32949451的博客
01-19 115
哈哈哈哈哈。。。呃~参考文章DAO 模式DAO (DataAccessobjects 数据存取对象)是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来。对外提供相应的接口在面向对象设计过程中，有一些"套路”用于解决特定问题称为模式。DAO 模式提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分离对上层提供面向对象的数据访问接口。从以上 DAO...
OOP设计原理&常见的设计模式
weixin_65975275的博客
06-21 2012
Java常见的几种设计模式&&OOP设计原理
设计模式学习（汇总版）
fengxiandada的博客
10-05 1307
设计模式学习，不只是书本上的知识，还有笔者平时工作中的应用
设计模式基本原则的理解
Wu_Shang001的博客
07-11 179
单一职责原则 记一下英文名 Single Responsibility Principle (srp)，防止以后看到不认识。 定义：应该有且仅有一个原因引起类的变更。 即一个类只负责一个职责。 理解 因为如果一个类负责太多的职责的话： 不易维护，当其中一个职责变化而修改这个类时，可能会影响到其他职责的功能。 可读性差，将大量的职责放在一个类里面，导致代码不易理解。 反过来，单一职责的优点就是： 降低类的复杂度 提高类的可读性，提供系统的可维护性 变更引起的风险降低，如果单一职责划分的好，修改一个功
初探Java设计模式5：一文了解Spring涉及到的9种设计模式
Java技术江湖
09-28 848
本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下Star、fork哈 文章也将发表在我的个人博客，阅读体验更佳： www.how2playlife.com 设计模式作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记...
第13章 层次式架构设计理论与实践
辣香牛肉面的博客
05-28 1031
软件体系结构为软件系统提供了结构、行为和属性的高级抽象，由构成系统的元素描述、这些元素的相互作用、指导元素集成的模式以及这些模式的约束组成。软件体系结构不仅指定了系统的组织结构和拓扑结构，并且显示了系统需求和构成系统的元素之间的对应关系，提供了一些设计决策的基本原理，是构建于软件系统之上的系统级复用。软件体系结构贯穿于软件研发的整个生命周期内，具有重要的影响。这主要从以下三个方面来进行考察。(1)利益相关人员之间的交流。(2)系统设计的前期决策。(3)可传递的系统级抽象。
我的毕业设计后端技术栈
finalheart的博客
05-04 2453
这篇文章是我写毕设后端遇到的一些问题。 一技术栈 最近在写毕业设计。对于后端的技术栈我是由以下技术完成的。对于毕设内容不作介绍了。说一说遇到的一些问题和如何解决的。 java1.8 springboot2.1.3 maven mysql 5.7 redis 2.18 mybatis tk-mapper jetcache freemaker webSocket g...
图书馆管理系统概要设计.docx
06-09
系统的目标用户是哈尔滨工程大学（简称“哈工程”），运行单位为软件开发小组。 ##### 1.3 定义 **Java EE应用的分层模型**主要包括以下几层： - **Domain Object (领域对象)层**：该层包含一系列POJO（Plain Old ...
大话设计模式（更新ing...）
qq_45599754的博客
10-17 1733
Java设计模式
毕业设计论文SpringBoot+Vue畅销图书推荐系统.docx
10-16
毕业设计论文
（自适应手机版）html5蓝色装修工程建设类企业网站响应式整站模板_网站整站打包下载.zip
10-16
（自适应手机版）html5蓝色装修工程建设类企业网站响应式整站模板_网站整站打包下载.zip
毕业设计论文Django+Vue新生入学管理系统.docx
10-16
毕业设计论文
毕业设计论文Nodejs+Vue摄影分享网站.docx
10-16
毕业设计论文
基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip
10-16
基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip基于Seq2Seq模型的机器翻译系统源码+模型+数据集.zip基于Se 【说明】 【1】项目代码完整，确保稳定可靠运行后才上传。欢迎下载使用！在使用过程中，如有问题或建议，请及时私信沟通，帮助解答。 【2】项目主要针对各个计算机相关专业，包括但不限于计科、信息安全、数据科学与大数据技术、人工智能、通信、物联网等领域的在校学生、专业教师或企业员工使用。 【3】项目具有较高的学习借鉴价值，不仅适用于小白学习入门进阶。也可作为毕设项目、课程设计、大作业、初期项目立项演示等。 【4】如果基础还行，或热爱钻研，可基于此项目进行二次开发，DIY其他不同功能，欢迎交流学习。 【特别强调】 项目下载解压后，项目名字和项目路径不要用中文，建议解压重命名为英文名字后再运行！项目易上手运行 使用过程遇到问题先搜索下，一般都是环境问题，当然也可以私信沟通，祝顺利！
postgresql-13.0.tar
10-16
postgresql-13.0.tar
机器人算法的C++实现-包括定位+建图+SLAM+路径规划+控制-优质项目实战.zip
最新发布
10-16
机器人算法的C++实现_包括定位+建图+SLAM+路径规划+控制_优质项目实战
JavaEE DAO设计模式解析
"JavaEE技术-DAO设计模式的讲解涵盖了DAO设计模式的概念、优势和实现步骤，强调了它在数据层操作中的应用，以解决JDBC操作数据库时代码混乱、可维护性差的问题。DAO模式主要包括DAO接口、实现类、工厂类、VO类和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值