关于DAO的类（操作数据库）

最新推荐文章于 2022-09-07 21:05:59 发布
最新推荐文章于 2022-09-07 21:05:59 发布
阅读量162 收藏
点赞数
分类专栏： Personal Favorite 文章标签： DAO SQL Java Apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/joni_wang/article/details/83289206
版权 
可以拿去用咯~
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;   
    }   
  
  
}  

 
joni_wang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sql增删改查等操作的返回值---dao层方法返回值
weixin_44769957的博客
09-28 5546
https://www.cnblogs.com/linqingvoe/p/10909768.html 增加和更新：比如增加或更新一个学生(Student)，参数类型是Student,返回值是可有可无（void 或object类型）。 删除：比如删除一个学生，参数类型是定义类型（Student）的属性（sid 或sname）,返回值可有可无（（void 或object类型） 查询: 1.查询单个学生：比如通过用户名查询单个学生信息，参数类型是定义类型（Student）的属性（sid 或sname）,返回值是定
DAO数据库安装文件
05-16
安装软件时，如果数据库缺失可以用它来安装。
【Java】自定义泛型类
dengmsjava的博客
03-30 5493
自定义泛型类 (1) 语法：Class 类名<T, R…>{//…表示可以有多个泛型成员}，T，R和M为泛型的标识符，一般是单个大写字母。 (2) 使用注意事项： ① 普通成员（属性、方法）可以是使用泛型； ② 使用泛型的数组，不能初始化； ③ 静态方法中不能使用类的泛型，因为静态是和类相关的，在类加载时，对象还没有创建，所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化； ④ 泛型类的类型是在创建对象时确定的（因为创建对象时，需要指定确定类型）；
DAO层添加数据成功返回主键ID
qq_40312909的博客
11-18 1006
返回结果 mapper文件需配置 这样主键ID才会返回
利用Spring框架为自己的校园卡充值。
m0_72151428的博客
09-07 1912
Spring框架的运用——实现学生卡的单次充值
详解DAO类（数据库操作对象）
m0_45311187的博客
01-23 1万+
DAO类下的各种关系可以用一张图来表示。 1.DAO类介绍: 1.介绍 1) DAO=DataBase Access Object; 数据库操作对象 2) 在一个DAO类中封装针对某张表操作细节 3) 在项目中所有的DAO类都应该存放在dao包 4) DAO类命名规则 = 表名+Dao DeptDao/EmpDao 例如这样一张表。 1.实体类介绍: 一个实体类用于描述一张表的结构 2) 实体类的类名应该与表名相同的 dept.frm-------- Dept.class 3) 实体类的属性名应该
【JDBC】-- DAO实现操作数据库
张修宇的博客
07-27 2223
DAO（DataAccessObject）访问数据信息的类和接口，包括对数据的CRUD，而不包含任何业务相关的信息。
9.DAO数据库操作演示（Visual C++编程 源代码）
06-26
9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示（Visual C++编程 源代码）9.DAO数据库操作演示...
dao3.5数据库+引擎.zip
07-10
它会将必要的DLL和OCX文件复制到系统目录，注册这些文件以便于其他应用程序能够调用DAO接口进行数据库操作。安装过程可能会涉及到设置环境变量，确保系统路径包含DAO的库文件，例如dbdao35.dll。此安装程序对于那些...
数据库DAO类
03-30
### 数据库DAO类知识点解析 #### 一、概述 在软件开发中，DAO（Data Access Object）模式是一种常用的设计模式，用于将数据访问逻辑从业务逻辑中分离出来。本篇文章将详细解读一个简单的数据库DAO类的实现方式及其...
Dao3.5数据库引擎
11-05
DAO（Data Access Objects）是微软在早期开发的一种数据库访问技术，它是Microsoft Jet数据库引擎的一部分，主要用于与Access...在处理类似问题时，了解DAO的基本原理和操作步骤，对解决MCGS数据库连接问题至关重要。
C#分享辅助类：SQLite数据库操作（SQLiteDao）
03-14
本篇文章将深入探讨如何利用C#创建一个名为`SQLiteDao`的辅助类来实现对SQLite数据库的操作。我们将讨论相关的类、方法以及如何使用它们来执行常见的数据库操作。 首先，`SQLiteDao`类是数据库操作的核心，通常包含...
DAO（DataBaseConnection）（用来获取数据库连接的类）
longyuan20102011的专栏
02-27 3690
package com.javaweb; import java.sql.*; import org.omg.CORBA.PUBLIC_MEMBER; public class DataBaseConnection { private final String DBDRIVER="com.mysql.jdbc.Driver"; private final String DBURL="j
JDBC中Dao层
whycmpx的博客
12-26 3万+
一、DAO模型DAO（Date Access Object） 模型就是写一个类，把访问数据库的代码封装起来，DAO在数据库与业务逻辑（Service）之间。1、实体域，即操作的对象，例如我们操作的表示user表，那么就需要先写一个User类； 2、DAO模型需要先提供一个DAO接口； 3、然后再提供一个DAO接口的实现类； 4、再编写一个DAO工厂，Service通过工厂来获取DAO实现； 二、面向
java中的Dao类是什么意思
热门推荐
技术黑板
06-23 3万+
DAO类都是进行数据操作的类， 是对于数据库中的数据做增删改查等操作的代码。 DAO(Data Access Object) 数据访问对象是一个面向对象的数据库接口，它显露了 Microsoft Jet 数据库引擎（由 Microsoft Access 所使用），并允许 Visual Basic 开发者通过 ODBC 像直接连接到其他数据库一样，直接连接到 Access 表。DAO 最适用于单...
RK3576-Hardware-Design-Guide
最新发布
08-21
包含datasheet
273教学质量评价系统.zip
08-21
摘 要 随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，教学质量评价系统当然也不能排除在外。教学质量评价系统是以实际运用为开发背景，运用软件工程开发方法，采用jsp技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本教学质量评价系统采用的数据库是Mysql，使用JSP技术开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。
VB访问数据库教程：JET与DAO的数据库操作
"这篇内容主要介绍了如何使用VB访问数据库，特别是通过JET和DAO技术...这篇内容深入浅出地解释了如何使用VB通过JET和DAO来操作数据库，同时也介绍了面向对象编程的基本概念，对于学习VB数据库编程的初学者非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值