JDBC（7）—DAO

最新推荐文章于 2020-12-27 22:37:28 发布
最新推荐文章于 2020-12-27 22:37:28 发布
阅读量402 收藏
点赞数
分类专栏： # Jdbc 文章标签： jdbc dao
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_P_F/article/details/76599946
版权

  1. 介绍：
    DAO(Data Access Object)：数据访问对象

    • 1.what：访问数据信息的类，包含了对数据的CRUD(create read、update、delete)，而不包含业务相关的信息。
      2.why：实现功能模块化，更有利于代码的维护和升级。
    • 3.how：使用JDBC编写DAO可能会包含的方法。
    • public void update(String sql, Object … objects)
    • public T get(Class clazz, String sql, Object … objects)
    • public List getForList(Class calzz, String sql, Object … objects)

    • public E getForValue(String sql, Object … objects)

    • 版本：1.0，之后还会对DAO进行修改，这只是一个非常简单的介绍。

2.实例：

DAO层代码
public class DAO1_7 {

    /**
     * 1.更新操作，insert、update、delete操作都包含在其中。
     * @param sql
     * @param objects
     */
    public void update(String sql, Object ...objects){
        Connection conn = null;
        PreparedStatement preparedstatement = null;
        try {
            conn = TestTools.getConnection();
            preparedstatement = conn.prepareStatement(sql);
            for(int i = 0; i < objects.length; i++){
                preparedstatement.setObject(i + 1, objects[i]);
            }
            preparedstatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            TestTools.release(preparedstatement, conn);
        }
    }
    /**
     * 2.查询一条记录，返回对应的对象。
     * @param clazz
     * @param sql
     * @param objects：占位符从1开始
     * @return
     */
    public <T> T get(Class<T> clazz,String sql,Object ...objects){
        T entity = null;
        Connection conn = null;
        PreparedStatement preparedstatement = null;
        ResultSet rs = null;
        ResultSetMetaData rsmd = null;
        try {
            //1.获取Connection
            conn = TestTools.getConnection();
            //2.获取PreparedStatement
            preparedstatement = conn.prepareStatement(sql);
            //3.填充占位符
            for(int i = 0; i < objects.length; i++){
                preparedstatement.setObject(i + 1, objects[i]);
            }
            //4.进行查询，获取ResultSet对象
            rs = preparedstatement.executeQuery();
            //5.若ResultSet中有数据，准备一个Map<String,Object>：键：存放列的别名，值：存放列的值
            if(rs.next()){
                Map<String,Object> values = new HashMap<String,Object>();   
                //6.得到ResultSetMetaData对象。
                rsmd = rs.getMetaData();
                //7.处理ResultSet，把指针向下移动一个单位。(在判断是否有数据是已经移动，此处不在需要)

                //8.ResultSetMetaData对象中得到结果集中有多少列
                int columnCount = rsmd.getColumnCount();
                //9.由ResultSetMetaData得到每一列的值，再由ResultSet得到具体每一列的值
                for(int i = 0; i < columnCount; i++){
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    Object columnValue = rs.getObject(i + 1);
                    //10.填充Map对象
                    values.put(columnLabel, columnValue);
                }
                //11.使用反射创建Class对应的对象
                entity = clazz.newInstance();
                //12.遍历Map对象，使用反射遍历填充对象的属性值，Map：key为属性名，value为属性值
                for(Map.Entry<String, Object> entry : values.entrySet()){
                    String propertyName = entry.getKey();
                    Object value = entry.getValue();

                    TestTools.setFieldValue(entity, propertyName, value);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            TestTools.release(rs, preparedstatement, conn);
        }
        return entity;
    }
    /**
     * 3.查询多条记录，返回对应的对象的集合。
     * @param calzz
     * @param sql
     * @param objects
     * @return
     */
    public <T> List<T> getForList(Class<T> calzz,String sql,Object ... args){
        List<T> list = new ArrayList<>();//用于返回多个对象
        Connection conn = null;
        PreparedStatement preparedstatement = null;
        ResultSet rs = null;
        try {
            //1.获取Connection连接
            conn = TestTools.getConnection();
            //2.获取PreparedStatement对象
            preparedstatement = conn.prepareStatement(sql);
            //3.填充占位符
            for(int i = 0; i < args.length; i++){
                preparedstatement.setObject(i + 1, args[i]);
            }
            //4.进行查询，获取ResultSet对象
            rs = preparedstatement.executeQuery();
            //5.若ResultSet中有数据，准备一个List<Map<String,Object>>：
            //键：存放列的别名，值：存放列的值，其中一个Map对象对应一条记录，values用于存放
            List<Map<String, Object>> values = new ArrayList<>();
            Map<String, Object> map = null;
            //6.得到ResultSetMetaData对象。
            ResultSetMetaData rsmd = preparedstatement.getMetaData();
            //7.处理ResultSet，使用while()循环。(在判断是否有数据是已经移动，此处不在需要)
            while(rs.next()){
                map = new HashMap<>();
                //8.把每个列别名和列值取出来，存到Map对象中
                for(int i = 0; i < rsmd.getColumnCount(); i++){
                    String columnName = rsmd.getColumnLabel(i + 1);
                    Object columnValue = rs.getObject(i + 1);

                    map.put(columnName, columnValue);
                }
                //9.再把Map对象存到List中
                values.add(map);

            }
            //12.判断List是否为空集合，若不空则便利List得到一个个Map对象，
            //再把Map对象转化成Class参数对应的Object对象
            T bean = null;
            if(values.size() > 0){
                for(Map<String, Object> m : values){
                    bean = calzz.newInstance();
                    for(Map.Entry<String, Object> entry : m.entrySet()){
                        String propertyName = entry.getKey();
                        Object propertyValue = entry.getValue();
                        //为类成员变量赋值。
                        TestTools.setFieldValue(bean, propertyName, propertyValue);
                    }
                    //13.把Object对象放入到list中
                    list.add(bean);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            TestTools.release(rs, preparedstatement, conn);
        }

        return list;
    }
    /**
     * 4_1.功能：查询多条记录，返回对应的对象的集合。对以上3.方法进行的拆分。
     *与上一致，其中对ResultSet对象之后的代码进行优化，包括每次循环都都要获取列别名进行优化修改。
     * @param calzz
     * @param sql
     * @param objects
     * @return
     */
    public <T> List<T> getForLists(Class<T> calzz,String sql,Object ... args){
        List<T> list = new ArrayList<>();//用于接收返回的多个对象
        Connection conn = null;
        PreparedStatement preparedstatement = null;
        ResultSet rs = null;
        try {
            //1.得到结果集
            conn = TestTools.getConnection();
            preparedstatement = conn.prepareStatement(sql);
            for(int i = 0; i < args.length; i++){
                preparedstatement.setObject(i + 1, args[i]);
            }
            rs = preparedstatement.executeQuery();
            //-----------------修改
            //2.处理结果集，得到Map的List，其中一个Map对象就是一条记录，Map中Key表示列别名，Value表示列值
            List<Map<String, Object>> values = handleResultSetToMapList(rs);
            //3.把Map的list转为Clazz对应的list，其中Map的Key表示Class的成员属性，Value表示成员属性的值
            list = transfterMapListToBeanList(calzz, values);

        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            TestTools.release(rs, preparedstatement, conn);
        }
        return list;
    }

    /**
     * 4_2.处理结果集，获取Map的List，其中一条Map对象对应一条记录。
     * @param rs
     * @return
     * @throws SQLException
     */
    private List<Map<String, Object>> handleResultSetToMapList(ResultSet rs)
            throws SQLException {
        List<Map<String, Object>> values = new ArrayList<>();
        Map<String, Object> map = null;
        //---------------此处被修改。6.得到ResultSetMetaData对象。
        List<String> columnLabels = getColumnLabels(rs);
        while(rs.next()){
            map = new HashMap<>();
            //---------------此处被修改。8.把每个列别名和列值取出来，存到Map对象中
            for(String columnName : columnLabels){
                Object columnValue = rs.getObject(columnName);
                map.put(columnName, columnValue);
            }
            values.add(map);
        }
        return values;
    }
    /**
     * 4_3获取结果集所有的列别名，存到集合中，再返回集合。
     * @param rs
     * @return
     */
    private List<String> getColumnLabels(ResultSet rs){
        List<String> labels = new ArrayList<>();
        try {
            ResultSetMetaData rsmd = rs.getMetaData();
            for(int i = 0; i < rsmd.getColumnCount(); i++){
                labels.add(rsmd.getColumnLabel(i + 1));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return labels;
    }
    /**
     * 4_4.
     * @param calzz
     * @param values
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    private <T> List<T> transfterMapListToBeanList(Class<T> calzz,
            List<Map<String, Object>> values) throws InstantiationException,
            IllegalAccessException {
        List<T> result = new ArrayList<>();
        T bean = null;
        if(values.size() > 0){
            for(Map<String, Object> m : values){
                bean = calzz.newInstance();
                for(Map.Entry<String, Object> entry : m.entrySet()){
                    String propertyName = entry.getKey();
                    Object propertyValue = entry.getValue();
                    //为类成员变量赋值。
                    TestTools.setFieldValue(bean, propertyName, propertyValue);
                }
                //13.把Object对象放入到list中
                result.add(bean);
            }
        }
        return result;
    }
    /**
     * 返回某条记录的某一个字段的值或一个统计的值（一共有多少条记录等。），即：确定的某一行的某个字段的值，或者计算的值
     * @param sql
     * @param objects
     * @return
     */
    public <E> E getForValue(String sql, Object ... objects){
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //1.得到结果集：该结果集应该只有一行，且只有一列
            conn = TestTools.getConnection();
            ps = conn.prepareStatement(sql);
            for(int i = 0; i < objects.length; i++){
                ps.setObject(i + 1, objects[i]);
            }
            rs = ps.executeQuery();
            if(rs.next()){
                //2.取得结果
                return (E) rs.getObject(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            TestTools.release(rs, ps, conn);
        }
        return null;
    }
}

测试dao层代码
public class DAOTest_1_7 {

    DAO1_7 dao = new DAO1_7();
    //测试：DAO——update(String sql, Object ...objects)方法。
    @Test
    public void testUpdate() {
        String sql = "insert into customers(name,age,birth,address) " +
                "value(?,?,?,?)";
        dao.update(sql, "刘飒","20",new Date(new java.util.Date().getTime()),"河南省");
    }

    //测试：DAO——get(Class<T> clazz,String sql,Object ...objects)方法。
    @Test
    public void testGet() {
        String sql = "select * from customers where id = ?";
        Customers customers = dao.get(Customers.class, sql, 12);
        System.out.println(customers);
    }

    //测试：DAO——getForList(Class<T> calzz,String sql,Object ... args)方法。
    @Test
    public void testGetForList() {
        String sql = "select FlowID ,Type , IDCard , ExamCard " +
    ", StudentName , Location , Grade  from examStudent";
        List<Student> student = dao.getForLists(Student.class, sql);
        for(int i = 0; i < student.size(); i++){
            System.out.println(student.get(i));
        }
    }

    //测试：DAO——getForValue(String sql, Object ... objects)
    @Test
    public void testGetForValue(){
        String sql = "select examCard from examstudent where FlowID = ?";
        String examCard = dao.getForValue(sql, 33);
        if(examCard == null){
            System.out.println("查无信息！");
        }else{
            System.out.println(examCard);
        }
        sql = "select Count(*) from examstudent";
        Object count = dao.getForValue(sql);
        System.out.println("共有："+count+"行");
    }
}
T_P_F
关注
专栏目录
java 判断记录集字段_Java判断数据库结果集ResultSet 中是否存在指定列名
weixin_29205061的博客
02-28 909
最近最项目，项目的持久化部分用的是spring jdbc，查询出来的结果集要映射为对象，每次都在查询SQL的方法内定义私有的mapper 变量，内部实现mapRow 方法，似乎有些浪费，就想着定义一个公用的mapRow 实现，节省代码，方便维护。在写的过程中，发现一个问题，就是涉及到一个很大的对象，属性非常多，但每次查询出来的属性却又都不一样，这样的公用mapRow 该怎么写呢，能否根据结果集中是...
数据结构与集合(六) --- 元素的比较
weixin_47081743的博客
10-11 513
元素的比较
不用判断循环判断某个字段是否存在
___ 、努ㄌ
02-26 1071
if (listMDFlowMeter.Exists(e => e.RelatedEquipment == GetBLDJobEquipmentByJobIdAndSeqNo(jobId, seqNo))){ equipment = listMDFlowMeter.Where(e => e.RelatedEquipment == GetBLDJobEquipmen
JDBC——判断ResultSet是否为含有元素
qq_41596538的博客
07-29 3255
ResultSet为空和ResultSet中没有元素是不同概念。   就像List&lt;String&gt; list =new ArrayList&lt;String&gt;(); list肯定不是null，但是list没有元素，所以说ResultSet即使是没有查询结果，也不会是空的，只是ResultSet中的元素为空。   ResultSet对象具有指向其当前数据行的指针。最初，...
JAVA的JDBC学习遇到的问题1
u011436445的博客
09-21 172
在实际学习Java的JDBC过程中遇到DAO创建过程中需要注意的事情。 这里我将DAO编写出一下大框架 1.Dao: data access object Dao 可以被子类直接继承 访问数据类包含对数据库的增删改查CRUD(create、read、update、delete); //insert 、delete 、update操作可能包含在其中 void upda...
JDBC+DAO.rar_DAO JDBC_java d_jdbc d_jdbc dao_留言系统
09-22
标题"JDBC+DAO.rar_DAO JDBC_java d_jdbc d_jdbc dao_留言系统"中，关键词主要包括"JDBC"、"DAO"和"留言系统"，这表明这是一个基于Java的数据库操作（JDBC）和数据访问对象（DAO）模式实现的简单留言系统。...
Java Web学生成绩管理系统（JSP+Servlet+JDBC+Dao）
01-24
编写该系统的目的是为了对学生的成绩进行信息化管理，降低教师管理的成本，提高工作效率。该系统有六张数据表：学生表、教师（管理员）表、成绩表、课程表、班级表、登录表。学生表和教师表用来存储系统用户；...
JDBC_DAO.rar
03-31
"JDBC_DAO.rar"这个压缩包文件显然包含了关于使用Java数据库连接（JDBC）实现数据访问对象（DAO）分层模型的相关资源。这是一个常见的设计模式，用于将业务逻辑与数据操作进行解耦，提高代码的可重用性和可维护性。 ...
基于JSP+Servlet+JavaBean+JDBC+DAO的Web图书管理架构设计该系统
11-10
基于JSP+Servlet+JavaBean+JDBC+DAO的Web架构设计该系统，进一步了解并掌握如何对数据库进行操作，以及如何分析、设计一个应用系统。 需求要求： 该系统的基本需求是，系统要实现如下的基本管理功能： （1）用户分为...
demo-dao-jdbc：使用JDBC的DAO实现
02-17
标题"demo-dao-jdbc：使用JDBC的DAO实现"表明这是一个示例项目，展示了如何在Java编程中使用JDBC（Java Database Connectivity）来实现数据访问对象（DAO）的设计模式。DAO模式是软件设计中常用的一种模式，它用于...
Java中泛型 Class＜T＞、T与Class＜?＞、 Object类和Class类、 object.getClass() 和 Object.class
热门推荐
freeking101的博客
10-23 1万+
From：Java中泛型 Class<T>、T与Class<?>、 Object类和 Class类、 object.getClass() 和 Object.class ：https://www.cnblogs.com/zhaoyanhaoBlog/p/9362267.html Class<T>和 Class<?>类型 有什么区别：https://www.jianshu.com/p/fecafcc83fba Java...
Spring知识总结
问题少年阿涛的博客
12-27 174
Spring知识总结 1、Spring中bean的生命周期（单例bean） 简单的说就是： 实例化（相当于new，开内存空间。属性值为默认值）--->初始化（相当于调用set，依赖注入，给属性赋值）--->销毁 稍微 ...
java项目中有哪些层?我知道有dao、service、util，还有什么？作用都是什么？
flyear_cn
08-09 9629
dao中存放于于数据库直接接触的类，maps中存放查询时使用的sql，service中存放服务实现的详细方法，action中存放某个功能的整体的实现方法。action调serveice,service调dao，dao要用到maps中的查询语句。util中存放最基本模板，以便调用。
数据库事务
晚晴小筑
08-14 580
数据库事务在数据库中,所谓事务是指一组逻辑操作单元,使数据从一种状态变换到另一种状态。 为确保数据库中数据的一致性,数据的操纵应当是离散的成组的逻辑单元:当它全部完成时,数据的一致性可以保持,而当这个单元中的一部分操作失败,整个事务应全部视为错误,所有从起始点以后的操作应全部回退到开始状态。 事务的操作:先定义开始一个事务,然后对数据作修改操作,这时如果提交(COMMIT),这些修改就永久地保
编程学习记录10：java数据库的连接
weixin_30875157的博客
07-23 82
用jdbc连接Oracle数据库 连接步骤 　　1、导包 　　2、加载驱动 　　3、建立连接 　　4、创建执行语句块 　　5、执行语句块，获得结果集 　　6、处理结果或结果集 　　7、关闭连接 DBHepler：功能简单，不支持事务 import java.lang.reflect.InvocationTargetException; import ...
Java中直接执行sql语句，返回List集合
luckytjx的专栏
09-12 1万+
Java中直接执行sql语句，返回List集合 public static List> getResultToList(String sql, Object... params) { PreparedStatement ps = null; Connection conn = getConnection(); ResultSet rs = null; List> rows =
Spring JDBC Template ,以及使用preparedstatements传参数
Sean的博客
11-18 8910
JdbcTemplate 被定义为一个Spring 管理的bean 该bean 是线程安全的，并且可以被不同的数据访问对象所共享，因此被定义为单利，JdbcTemplate 的bean主要依赖项为一个DataSource 对象， 所以，需要把创建的dataSource 对象注入到JdbcTemplat spring 将数据访问的样本代码抽象到模板类中 spring 为JDBC 提供了两种类型...
List<T> objects转换
我笔记
12-14 1037
using System; using System.Collections.Generic; namespace ListObjBoxingDemo {     internal class Point     {         public int X { get; set; }         public int Y { get; set; }     }     internal 
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值