02 DAO模式设计

最新推荐文章于 2024-10-08 15:41:48 发布
最新推荐文章于 2024-10-08 15:41:48 发布
阅读量127 收藏 1
点赞数
分类专栏： 原生JDBC 文章标签： 数据库 jdbc dao
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/japson_iot/article/details/79589088
版权

DAO模式设计

标签： jdbc

什么是DAO

Data Access Object，数据库访问对象，主要的功能就是用于进行数据操作的CRUD（create,read,update,delete），而不包含任何业务相关的信息。在程序的标准开发架构中属于数据层的操作。

实现了功能的模块化。更有利于代码的维护和升级。

如何编写DAO

DAO可以被继承或直接使用。使用JDBC编写DAO可能会包含的方法：

  • INSERT,UPDATE,DELDETE操作都可以包含在其中 void update(String sql,Object ... args);

  • 查询一条记录，返回对应的对象 <T> T get(Class<T> clazz,String sql,Object ... args);

  • 查询多条记录，返回对应的对象的集合 <T> List<T> getForList(Class<T> clazz,String sql,Object ... args);
  • 返回某条记录的某一个字段的值，或一个统计的值（一共有多少条记录等） <E> E getForValue(String sql,Object ... args);

BeanUtils获取Java类的属性

在JavaEE中，Java类的属性通过getter，setter来定义：get（或set）方法，取出get（或set）后首字母小写后即为Java类的属性

以前所说的属性，也就是成员变量，称之为字段。

操作Java类的属性有一个工具包：beanutils
我们需要在项目中导入beanutils以及logging的jar包
我们通过beanutils工具包的方法来操作属性：
给对象object的属性赋值：

BeanUtils.setProperty(Object bean,String name,Object value);

获取对象object的属性：

Object val = BeanUtils.getProperty(Object bean,String name);

DAO中的方法

增删改操作：update

/**
     * INSERT,UPDATE,DELDETE操作都可以包含在其中
     * @param sql 传入的sql语句
     * @param args 占位符的可变参数
     */
    public void update(String sql, Object... args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCTools.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(null, preparedStatement, connection);
        }
    }

查询单条记录操作：get

 /**
     * 查询一条记录，返回对应的对象
     * @param clazz 要查询的对象的类
     * @param sql 传入的sql语句
     * @param args 占位符的可变参数
     * @param <T> 泛型
     * @return
     */
    public <T> T get(Class<T> clazz, String sql, Object... args) {
        T entity = null;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //1. 获取Connection连接
            connection = JDBCTools.getConnection();
            //2. 获取PreparedStatement对象
            preparedStatement = connection.prepareStatement(sql);
            //3. 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            //4. 进行查询，达到结果集
            resultSet = preparedStatement.executeQuery();
            //5. 创建一个Map
            Map<String, Object> map = new HashMap<>();
            //6. 得到ResultSetMetaData对象
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            //7. 处理结果集，指针向下移
            //while循环没进来，把前面的if(resultSet.next())去掉就好了
            while (resultSet.next()) {
                //8. 得到ResultSetMetaData的列数
                int columnCount = resultSetMetaData.getColumnCount();
                //9. 由ResultSetMetaData得到每一个列的别名，由ResultSet得到具体每一列的值
                for (int i = 0; i < columnCount; i++) {
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                    Object columnValue = resultSet.getObject(i + 1);

                    //10.填充Map
                    map.put(columnLabel, columnValue);
                }

                //11. 利用反射创建Class实体对象
                entity = clazz.newInstance();
                //12. 遍历Map对象，用反射填充对象的属性值
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();

                    //ReflectionUtils.setFieldValue(entity, propertyName, value);
                    BeanUtils.setProperty(entity, propertyName, value);
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(resultSet, preparedStatement, connection);
        }
        return entity;
    }

查询多条记录操作getForList

 /**
     * 查询多条记录，返回对应的对象的集合
     * @param clazz 要查询的对象的类
     * @param sql 传入的sql语句
     * @param args 占位符的可变参数
     * @param <T> 泛型
     * @return
     */
    public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
        List<T> list = new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //1. 建立Connection连接
            connection = JDBCTools.getConnection();

            //2. 创建PreparedStatement对象
            preparedStatement = connection.prepareStatement(sql);

            //3. 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            //4. 查询得到结果集
            resultSet = preparedStatement.executeQuery();

            //5. 准备多个Map：List<Map<String,Object>>，每一个Map对应一条查询记录
            List<Map<String, Object>> values = new ArrayList<>();

            //6. 得到ResultSetMetaData对象
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

            Map<String, Object> map = null;
            //7. 处理ResultSet，使用while循环
            while (resultSet.next()) {
                //集合中的每一个map
                map = new HashMap<>();

                //8. 得到ResultSetMetaData的列数
                int columnCount = resultSetMetaData.getColumnCount();

                //9. 由ResultSetMetaData得到字段的别名，由ResultSet得到字段的值
                for (int i = 0; i < columnCount; i++) {
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                    Object value = resultSet.getObject(i + 1);

                    //10. 填充Map对象
                    map.put(columnLabel, value);
                }

                //11. 把填充好的Map对象放入List中
                values.add(map);
            }

            //12. 判断List是否为空集合，若不为空，则遍历List，得到一个一个的Map对象
            //再把Map对象转为一个Class参数对应的Object对象
            T bean = null;

            if (values.size() > 0) {

                //遍历列表中的map
                for (Map<String, Object> m : values) {
                    //每找到一个map，就要利用反射创建一个实例对象
                    bean = clazz.newInstance();
                    //通过遍历map中的键值对，给实例对象赋值
                    for (Map.Entry<String, Object> entry : m.entrySet()) {
                        String propertyName = entry.getKey();
                        Object value = entry.getValue();
                        //通过beanUtils给对象的属性赋值
                        BeanUtils.setProperty(bean, propertyName, value);
                    }

                    //13.把Object对象放入到List中
                    list.add(bean);

                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(resultSet, preparedStatement, connection);
        }

        return list;
    }

重构getForList

将很多方法抽取出来，重构

/**
     * 查询多条记录，返回对应的对象的集合
     * @param clazz 要查询的对象的类
     * @param sql 传入的sql语句
     * @param args 占位符的可变参数
     * @param <T> 泛型
     * @return
     */
    public <T> List<T> getForList(Class<T> clazz, String sql, Object... args) {
        List<T> list = new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //1. 得到结果集
            connection = JDBCTools.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            resultSet = preparedStatement.executeQuery();

            //2. 处理结果集，得到Map的一个List，其中一个Map对象对应一条记录
            //其中Map的key为resultSet中列的别名，Map的value为列的值。
            List<Map<String, Object>> values = handleResultSetToMapList(resultSet);

            //3. 把Map的List转为clazz对应的list
            // 其中Map的key为clazz对应的对象的propertyName，Map的值为clazz对应的对象的propertyValue
            list = transfterMapListToBeanList(clazz, values);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(resultSet, preparedStatement, connection);
        }

        return list;
    }


    /**
     * 将Map列表中的键值对赋给list对象中
     * @param clazz
     * @param values
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    private <T> List<T> transfterMapListToBeanList(Class<T> clazz, List<Map<String, Object>> values) throws InstantiationException, IllegalAccessException, InvocationTargetException {

        List<T> result = new ArrayList<>();

        T bean = null;
        System.out.println(values.size());
        if (values.size() > 0) {

            //遍历列表中的map
            for (Map<String, Object> m : values) {
                //把它从内层的for循环拿出来
                bean = clazz.newInstance();
                //遍历map中的键值对
                for (Map.Entry<String, Object> entry : m.entrySet()) {
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();

                    BeanUtils.setProperty(bean, propertyName, value);
                }

                //13.把Object对象放入到List中
                result.add(bean);

            }
        }
        return result;
    }

    /**
     * 处理结果集，得到Map的一个List，其中一个Map对象对应一条记录
     * @param resultSet 结果集
     * @return list
     * @throws SQLException
     */
    private List<Map<String, Object>> handleResultSetToMapList(ResultSet resultSet) throws SQLException {
        //5. 准备多个Map：List<Map<String,Object>>，每一个Map对应一条查询记录
        List<Map<String, Object>> values = new ArrayList<>();

        //6. 得到ResultSetMetaData对象
        //ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

        //调用方法
        List<String> columnLabels = getColumnLabels(resultSet);

        Map<String, Object> map = null;

        //7. 处理ResultSet，使用while循环
        while (resultSet.next()) {
            map = new HashMap<>();

            //8. 得到ResultSetMetaData的列数
            //int columnCount = resultSetMetaData.getColumnCount();

            //9. 由ResultSetMetaData得到字段的别名，由ResultSet得到字段的值
            for (String columnLabel : columnLabels) {
                //String columnLabel = resultSetMetaData.getColumnLabel(i + 1);
                Object value = resultSet.getObject(columnLabel);

                //10. 填充Map对象
                map.put(columnLabel, value);
            }

            //11. 把填充好的Map对象放入List中
            values.add(map);
        }
        return values;
    }

    /**
     * 获取结果集的ColumnLabel对应的集合List
     * @param resultSet
     * @return
     * @throws SQLException
     */
    private List<String> getColumnLabels(ResultSet resultSet) throws SQLException {
        List<String> labels = new ArrayList<>();
        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
        for (int i = 0;i < resultSetMetaData.getColumnCount();i++) {
            labels.add(resultSetMetaData.getColumnLabel(i+1));
        }
        return labels;
    }

重构get方法

利用getForList方法重构get方法

    /**
     * 查询一条记录，返回对应的对象
     * @param clazz 要查询的对象的类
     * @param sql 传入的sql语句
     * @param args 占位符的可变参数
     * @param <T> 泛型
     * @return
     */
    public <T> T get(Class<T> clazz, String sql, Object... args) {
        List<T> result = getForList(clazz,sql,args);
        if (result.size() > 0) {
            return result.get(0);
        }
        return null;
    }
Japson_z
关注
专栏目录
java dao设计模式_JavaDAO设计模式
weixin_28913879的博客
02-12 755
JavaDAO设计模式DAO 模式入门1. 什么是 DAO 模式DAO 模式是标准的 J2EE 设计模式之一. 开发人员使用这个模式把底层的数据访问操作和上层的业务逻辑分开，此模式的主要作用是封装对数据库的各种操作；2.DAO 模式的组成部分VO：值对象，此对象只包含属性，而没有方法；代表数据库中表中的一条记录，一个 VO 与一个表是相对应的DAO 接口：定义对某个 VO 的所有操作DAO 实现类...
Java数据库操作DAO设计模式
往事似水拂流年的博客
06-14 982
DAO（Database Access Object，数据库访问对象） 为了降低耦合性，提出了DAO封装数据库操作的设计模式。 优点：它可以实现业务逻辑与数据库访问相分离，相对来说，数据库是比较稳定的，其中数据库依赖于数据库系统，提供数据库访问的接口。 DAO模式的组成部分 DAO接口（主要是添加、修改、更新和删除方法） DAO实现类 实体类（一般存放于domain、beans、ent...
DAO设计模式
qq_45440786的博客
03-01 771
DAO模式将这些操作封装在数据访问对象中，而不是将其直接写在业务逻辑中，从而使得业务逻辑和数据访问逻辑之间的耦合度更低。总之，DAO模式的存在使得软件开发更具可维护性、可测试性、可重用性和安全性，它已经成为了一种常见的设计模式，在很多软件开发项目中被广泛应用。在软件开发中，DAO是指数据访问对象（Data Access Object），是一种设计模式，用于将应用程序的业务逻辑和数据存储操作分离。可维护性：通过DAO模式，数据访问逻辑和业务逻辑被分离，使得代码组织更为清晰，易于维护和修改。
JavaWeb-DAO设计模式
Alphamilk的博客
08-17 1638
DAO设计模式、1.认识DAO、2.DAO各部分的详解、3.DAO设计模式流程、4.具体案例
Dao设计模式
weixin_44811903的博客
06-01 1376
设计模式
面向接口设计——Dao模式
qq_36919391的博客
08-28 526
面向接口设计——Dao模式 DAO（Data Access Object）模式就是写一个类，把访问数据库的代码封装起来。DAO在数据库与业务逻辑（Service）之间。 实体域，即操作的对象，例如我们操作的表是emp表，那么就需要先写一个employee类； DAO模式需要先提供一个DAO接口； 然后再提供一个DAO接口的实现类； 再编写一个DAO工厂，Service通过工厂来获取DAO...
Dao模式及单例设计模式
Super_Robot的博客
06-06 1023
Dao模式及单例设计模式 优化、简化。封装JDBC操作。 一、 什么是DAO模式？ 传统的JDBC操作：(问题) 加载驱动和建立连接的步骤冗余/重复 思考解决方案：提取成公共的方法 释放资源/关流步骤冗余/重复 思考解决方案：提取成公共的方法 业务代码和数据访问代码耦合在一起 阅读困难 数据访问代码复用性差 思考解决方案：将业务代码和数据访问代码分离 ，无非也就是抽取成方法或类 ...
DAO 模式 详解
热门推荐
编程大白菜
10-25 1万+
DAO模式 DAO（Data Access Object）数据访问对象。主要的功能就是用于进行数据操作的，在程序的标准开发架构中属于数据层的操作 先来看基本的架构分层 企业分层架构： 客户层：B/S结构都使用浏览器，C/S结构则是一个客户端 显示层：使用JSP/Servlet进行页面效果的显示 业务层：（Business Object，业务对象）：会将多个原子性的DAO操作进行组合，组合成一个完整的业务逻辑。 数据层（DAO）：提供多个原子性的DAO操作（数据持久化操作），例如：增加、修改、删除等，都属于
JavaDAO设计模式学习总结
weixin_37998544的博客
11-16 709
JavaDAO模式基础 1.DAO模式理解 DAO模式是J2EE设计模式之一，开发人员为了降低耦合性，把底层的数据访问操作和上层的业务逻辑分开，此设计模式的主要作用是封装对数据库的操作； ...
DAO设计模式的介绍与实现
wd
11-10 1万+
前言：哈哈，第一篇关于Java的博客了，暑假看了一些Java的设计模式，本来想着总结一下的，但是一耽误就到现在了，后面慢慢补上。今天我们来聊聊DAO 1、DAO是个什么东西呢? 看一下官方的介绍，DAO（Data Access Object，数据访问对象）的主要功能是数据操作，在程序的标准开发架构中属于数据层的操作。额，好像有点糊涂啊，用人类的语言解释一下也就是DAO是一种操作数据库的设计
DAO模式设计
03-01
DAO模式的核心思想是通过创建一个独立于具体数据库操作的对象（即DAO），来封装对数据库的访问细节，这样可以使得业务代码不直接依赖于具体的数据库API，提高了代码的可测试性和可维护性。 在现代Java应用中，尤其...
浅谈对于DAO设计模式的理解
08-29
浅谈DAO设计模式的理解 DAO（Data Access Object）设计模式是一种常用的软件设计模式，它的主要目的是将业务逻辑与数据库访问相分离，降低耦合性，提高系统的可维护性和扩展性。下面是对DAO设计模式的理解和实现的...
MVC+DAO设计模式下的设计流程详解
08-28
MVC+DAO设计模式是当前软件开发中常用的设计模式，它将Model、View、Controller三层架构结合DAO模式，实现了数据访问的解耦和业务逻辑的处理。通过MVC+DAO设计模式，可以使项目在设计过程中结构更为明晰，并且能够...
DAO.zip_dao模式jsp修改_java DAO设计
09-24
在JSP（JavaServer Pages）中，DAO模式通常用于处理与数据库交互的任务，以避免在表现层（如JSP页面）直接进行SQL操作。 1. **DAO接口和实现类**： 在DAO模式中，首先定义一个接口，例如`UserDAO`，该接口声明了...
鲁班到家上门安装维修系统源码开发之结构功能解析
最新发布
weixin_43744973的博客
10-08 912
鲁班到家上门安装维修系统的源码开发是一个复杂但富有成效的过程。通过详细的需求分析、技术选型、功能模块设计以及前后端分离开发，该系统不仅提升了服务效率，还通过数字化管理优化了用户体验。未来，该系统有望在智能家居售后服务领域发挥更加重要的作用，引领行业向更加高效、专业、透明的方向发展。
MySQL之复合查询与内外连接
zdlynj的博客
09-30 1399
前面我们讲解的mysql表的查询都是对一张表进行查询，即数据的查询都是在某一时刻对一个表进行操作的。而在实际开发中，我们往往还需要对多个表同时进行查询。我们这里使用的测试表，为雇员信息表(来自Oracle 9i的经典测试表)：EMP员工表，DEPT部门表，SALGRADE工资等级表。
ATAM需求说明-系统架构师（七十六）
ke1ying的博客
10-08 793
1体系结构权衡分析法ATAM(Architecture Trade Off Analyzer Method)是一种常见的结构权衡分析法，该框架主要关注系统的（），针对性能、安全性、可用性和可修改性，在系统开发前进行分析、评价和这种。A共享数据库的集成方式通常将应用程序的数据存储在一个共享数据库中，通过制定统一的数据库模式来处理不同应用集成需求。场景和需求的收集，架构视图和场景的实现，属性模型的构造和分析，架构评价和折中。7企业信息资源集成管理的前提是对企业（）的集成，其核心是对企业（）的集成。
World of Warcraft [CLASSIC][80][Grandel] Call to Arms: Victory in Wintergrasp
qq 117791303
10-02 350
Wintergrasp 冬拥湖 120 VS 120
JavaEE DAO设计模式解析
DAO模式主要包括DAO接口、实现类、工厂类、VO类和数据库连接类五个部分，分别负责不同的职责，提升程序的结构清晰度和可扩展性。" DAO设计模式是JavaEE应用程序中常用的数据访问对象（DAO）设计模式，它的主要目的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值