DAO使用及实现示例

已于 2022-07-12 16:18:03 修改
阅读量541 收藏 2
点赞数
分类专栏： mysql 文章标签： 数据库
于 2022-07-12 10:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41636858/article/details/125737726
版权

  • DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。

  • 在所有的dao中会有很多重复性的工作，我们可以封装一个父类来完成此类重复工作，我们称之为BaseDAO。

一个比较全面的BaseDao

package com.xinzhi.dao.impl;

import com.xinzhi.dao.IBaseDao;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * @author zn
 * @date 2020/4/4
 **/
public class BaseDaoImpl<T> implements IBaseDao<T> {

    private static DataSource DATA_SOURCE = null;

    static {
        InputStream in = UserDaoImpl.class.getClassLoader().getResourceAsStream("config/jdbc.config");
        Properties properties = new Properties();
        try {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }

        HikariConfig hikariConfig = new HikariConfig(properties);
        BaseDaoImpl.DATA_SOURCE = new HikariDataSource(hikariConfig);
    }

    public Connection getConnection() {
        if (BaseDaoImpl.DATA_SOURCE != null) {
            try {
                return BaseDaoImpl.DATA_SOURCE.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public void closeAll(Statement statement, ResultSet resultSet) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //简单的通用保存，通过可变参数赋值
    public void save(String sql, Object... params) {
        PreparedStatement statement = null;
        try {
            Connection conn = getConnection();
            statement = conn.prepareStatement(sql);
            for (int i = 1; i <= params.length; i++) {
                statement.setObject(i, params[i]);
            }
            statement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, null);
        }
    }

    /**
     * 高级部分
     * 有要求 数据库的名字和类名必须一样
     * 每个字段和属性的名字也要一样
     * 有规矩好办事,重在体会思想
     * 搞明白还能这么干就行了
     * 思路：
     * 因为规定了数据库名称和类名形同，字段也相同
     * 所有可以通过反射获取类名和字段名拼接一个字符串
     *
     * @return
     */


    public List<T> findAll(Class clazz) {
        //拼一个sql   select id,username,password from user
        //其中id,username,password可变但是他是类的字段啊
        //user可变但是他是类名啊，反射登场了
        List<T> list = new ArrayList<>();
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            //利用反射拼出一个select语句
            Field[] fields = clazz.getDeclaredFields();
            StringBuilder fieldStr = new StringBuilder();
            fieldStr.append("select ");
            for (Field field : fields) {
                fieldStr.append(field.getName().toLowerCase()).append(",");
            }
            fieldStr.deleteCharAt(fieldStr.length() - 1);
            fieldStr.append(" from ");
            fieldStr.append(clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1));

            Connection conn = getConnection();
            statement = conn.prepareStatement(fieldStr.toString());
            resultSet = statement.executeQuery();

            while (resultSet.next()) {
                Object obj = clazz.newInstance();
                for (Field field : fields) {
                    Object value = resultSet.getObject(field.getName());
                    field.setAccessible(true);
                    field.set(obj, value);
                }
                list.add((T) obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, resultSet);
        }
        return list;
    }


    public void save(Object obj) {
        Class clazz = obj.getClass();
        Field[] fields = clazz.getDeclaredFields();

        //拼接出一个insert语句
        StringBuilder sql = new StringBuilder("insert into ");
        sql.append(clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1))
                .append(" (");
        for (Field field : fields) {
            sql.append(field.getName().toLowerCase()).append(",");
        }
        sql.deleteCharAt(sql.length() - 1);
        sql.append(") values (");
        for (Field field : fields) {
            sql.append("?,");
        }
        sql.deleteCharAt(sql.length() - 1);
        sql.append(")");
        System.out.println(sql);

        PreparedStatement statement = null;
        try {
            Connection conn = getConnection();
            statement = conn.prepareStatement(sql.toString());
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                statement.setObject(i + 1, fields[i].get(obj));
            }

            statement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, null);
        }
    }


    @Override
    public void update(Object obj, String fieldName, Object fieldValue) {
        PreparedStatement statement = null;
        try {
            Class clazz = obj.getClass();

            //拼接出一个update语句
            StringBuilder sql = new StringBuilder("update " + clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1)
                    + " set ");
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                sql.append(field.getName()).append("=").append("?").append(",");
            }
            sql.deleteCharAt(sql.length() - 1);
            sql.append(" where ").append(fieldName).append("=?");
            System.out.println(sql);

            Connection conn = getConnection();
            statement = conn.prepareStatement(sql.toString());
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                statement.setObject(i + 1, fields[i].get(obj));
            }
            statement.setObject(fields.length + 1, fieldValue);
            statement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, null);
        }
    }

    @Override
    public void delete(Class clazz, String fieldName, Object fieldValue) {
        //拼接一个delete语句
        String sql = "delete from " + clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1)
                + " where " + fieldName + "=?";
        System.out.println(sql);
        PreparedStatement statement = null;
        try {
            Connection conn = getConnection();
            statement = conn.prepareStatement(sql);
            statement.setObject(1, fieldValue);
            statement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, null);
        }
    }

    @Override
    public T findOne(Class clazz, String fieldName, Object fieldValue) {
        T t = null;

        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            Field[] fields = clazz.getDeclaredFields();
            //拼接一个语句
            StringBuilder sql = new StringBuilder();
            sql.append("select ");
            for (Field field : fields) {
                sql.append(field.getName().toLowerCase()).append(",");
            }
            sql.deleteCharAt(sql.length() - 1);
            sql.append(" from ");
            sql.append(clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1))
                    .append(" where " + fieldName + "=?");

            System.out.println(sql.toString());

            Connection conn = getConnection();
            statement = conn.prepareStatement(sql.toString());
            statement.setObject(1,fieldValue);
            resultSet = statement.executeQuery();

            while (resultSet.next()) {
                Object obj = clazz.newInstance();
                for (Field field : fields) {
                    Object value = resultSet.getObject(field.getName());
                    field.setAccessible(true);
                    field.set(obj, value);
                }
                t = (T) obj;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeAll(statement, resultSet);
        }
        return t;
    }
}

自己写的带注释版本的

package com.sdu.reflect;

import javax.sql.DataSource;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class BaseDaoImpl<T> implements IBaseDao<T> {
    private static DataSource DATA_SOURCE = null;
    /*使用的是 Hikari（光）数据库连接池
    static {
        InputStream in = UserDaoImpl.class.getClassLoader().getResourceAsStream("config/jdbc.config");
        Properties properties = new Properties();
        try {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }

        HikariConfig hikariConfig = new HikariConfig(properties);
        BaseDaoImpl.DATA_SOURCE = new HikariDataSource(hikariConfig);
    }
    */

    @Override
    public Connection getConnection() {
        if (BaseDaoImpl.DATA_SOURCE != null) {
            try {
                return BaseDaoImpl.DATA_SOURCE.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public void closeAll(Statement statement, ResultSet resultSet) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void save(Object obj) {
        Class clzz = obj.getClass();
        Connection conn = null;
        PreparedStatement statement = null;
        Field [] fields = clzz.getDeclaredFields();
        StringBuilder sb = new StringBuilder();
        sb.append("insert into ").append(clzz.getName().toLowerCase().substring(clzz.getName().lastIndexOf(".")+1));
        sb.append(" (");
        for (Field field:fields
             ) {
            sb.append(field.getName().toLowerCase()).append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        sb.append(") values (");
        System.out.println(sb.toString());
        try {
            conn = getConnection();
            statement = conn.prepareStatement(sb.toString());
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                statement.setObject(i+1, fields[i].get(obj));
            }
            statement.execute();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } finally {
            closeAll(statement,null);
        }
    }

    @Override
    public  List<T> findAll(Class clazz) {
        List<T> list = new ArrayList<>();
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Field [] fields = clazz.getFields();
        StringBuilder fieldBuilder = new StringBuilder();
        fieldBuilder.append("select ");
        for(Field field: fields){
            fieldBuilder.append(field.getName().toLowerCase()).append(",");
        }
        fieldBuilder.deleteCharAt(fieldBuilder.length()-1);
        fieldBuilder.append(" from ");
        fieldBuilder.append(clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".") + 1));

        Connection conn = getConnection();
        try {
            statement = conn.prepareStatement(fieldBuilder.toString());
            resultSet = statement.executeQuery();
            while (resultSet.next()){
                Object obj = clazz.newInstance();
                for (Field field: fields){
                    Object value = resultSet.getObject(field.getName());
                    field.setAccessible(true);
                    field.set(obj,value);
                }
                list.add((T)obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            closeAll(statement,resultSet);
        }
        return list;
    }

    @Override
    public void update(Object obj, String fieldName, Object fieldValue) {
        //其实是用传进来的obj中的对象的值来更新数据的值,fieldName是条件名,fieldValue是条件值

        ResultSet resultSet = null;
        PreparedStatement ps = null;
        Class clzz = obj.getClass();
        Field[] fields = clzz.getDeclaredFields();
        StringBuilder sb = new StringBuilder("update " + clzz.getName().toLowerCase().substring(clzz.getName().lastIndexOf(".")+1) + " set ");

        for (Field field:fields
             ) {
            field.setAccessible(true);
            sb.append(field.getName()).append("=").append("?").append(",");
        }
        sb.deleteCharAt(sb.length()-1);
        sb.append(" where ").append(fieldName).append("=?");
        System.out.println(sb.toString());

        Connection conn = getConnection();
        try {
            ps = conn.prepareStatement(fields.toString());
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                ps.setObject(i+1,fields[i].get(obj));
            }
            ps.setObject(fields.length + 1, fieldValue);
            ps.execute();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }finally {
            closeAll(ps,null);
        }
    }

    @Override
    public void delete(Class clazz, String fieldName, Object fieldValue) {
        String sql = "delete from " + clazz.getName().toString().toLowerCase().substring(clazz.getName().toString().lastIndexOf(".") + 1)
                +" where " + fieldName +"=?";
        PreparedStatement ps = null;
        System.out.println(sql);
        Connection conn = getConnection();
        try {
            ps = conn.prepareStatement(sql);
            ps.setObject(1,fieldValue);
            ps.execute();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            closeAll(ps,null);
        }
    }

    @Override
    public T findOne(Class clazz, String fieldName, Object fieldValue) {
        PreparedStatement ps = null;
        Connection con = getConnection();
        ResultSet rs = null;
        T t = null;
        Field [] fields = clazz.getDeclaredFields();
        StringBuilder sql = new StringBuilder();
        sql.append("select ");
        for (int i = 0; i < fields.length; i++) {
            sql.append(fields[i].toString().toLowerCase()).append(",");
        }
        sql.deleteCharAt(sql.length()-1);
        sql.append(" from ");
        sql.append(clazz.getName().toLowerCase().substring(clazz.getName().lastIndexOf(".")+1));
        sql.append(" where ").append(fieldName+"=?");
        System.out.println(sql.toString());
        try {
            ps = con.prepareStatement(sql.toString());
            ps.setObject(1,fieldValue);
            rs = ps.executeQuery();
            while(rs.next()){
                Object obj = clazz.newInstance();
                for (Field field:fields
                     ) {
                    Object value = rs.getObject(field.getName());
                    field.setAccessible(true);
                    field.set(obj,value);
                }
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }finally {
            closeAll(ps,rs);
        }
        return t;
    }
}

小林嘞
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dao层不能被实例化、Invalid bound statement (not found)错误、List<Student>采用foreach的遍历方法
m0_37635053的博客
08-29 612
dao层不能被实例化：**** 原因，导入的包不不正确。应该导入： org.mybatis.spring.boot mybatis-spring-boot-starter 1.3.0 BInvalid bound statement (not found)错误： ***1、易错点：检查xml文件所在的package名称是否和interface对应的package名称一一对应（为了这个我费尽半天...
java dao例子_java 设计模式（DAO）的实例详解
weixin_39750598的博客
02-13 173
java 设计模式(DAO)的实例详解应用场景：在Java程序中，经常需要把数据持久化，也需要获取持久化的数据，但是在进行数据持久化的过程中面临诸多问题(如：数据源不同、存储类型不同、供应商不同、访问方式不同等等)，请问如何能以统一的接口进行数据持久化的操作？其实这个我没学号(≧ ﹏ ≦)。我的理解就是一个产品面向的用户不是单一的，所以我们要兼容许多情况如前面提到的数据源不同、存储类型不同、供应商...
mybatis源码阅读(四)：mapper(dao)实例化
茅坤宝骏氹的博客
01-27 402
转载自 mybatis源码阅读(四)：mapper(dao)实例化 在开始分析之前，先来了解一下这个模块中的核心组件之间的关系，如图： 1.MapperRegistry&MapperProxyFactory MapperRegistry是Mapper接口及其对应的代理对象工程的注册中心，Configuration是Mybatis全局性的配置对象，在初始化的过程中，所有配置信息...
【java】Dao封装数据库，连接池技术
qq_57420582的博客
07-16 207
【java】Dao封装数据库，连接池技术
数据——DAO层应用
qq_45947664的博客
06-25 788
数据——DAO层应用 配置Mapper文件扫描，在application文件中，用mybatis扫描文件路径 实现了dao层到mapper层的映射 在application.properties文件中添加配置 认识mapper文件 Dao⽂件是通过xml⽂件中的namespace（命名空间）进⾏定位关联 Dao中的⽅法与xml⽂件中的标签进⾏关联（通过⽅法名称和标签id进⾏ 匹配） Dao.xml文件中有标签对 Select PS
Java之dao模式详解及代码示例
08-28
例如，可以定义一个DAO接口，声明了对于数据库的操作，然后可以通过实现这个接口来实现具体的DAO实现类。 在实际的开发中，DAO模式可以广泛应用于各种数据访问操作，例如 CURD（Create、Retrieve、Update、Delete）...
java ssh通用DAO另类实现示例
12-27
java ssh通用DAO另类实现示例 java ssh通用DAO另类实现示例
使用JDBC实现数据访问对象层（DAO）代码示例
08-29
使用JDBC实现数据访问对象层（DAO）代码示例 在软件开发中，数据访问对象层（DAO）是一种常见的设计模式，它提供了一种抽象的方式来访问和操作数据库中的数据。使用JDBC（Java Database Connectivity）实现DAO可以...
super-dao:Java 的 DAO 模式的示例实现
06-29
超级道 Java 的 DAO 模式的示例实现。
dao-design-pattern:用PHP实现DAO设计模式的示例
03-30
dao-design-pattern
简单DAO层示例
07-26
NULL 博文链接：https://quicker.iteye.com/blog/666673
DAO应用程序开发者(For C# Oracle)
11-24
作者多年开发经验积累，根据项目建设需要，开发的DAO应用程序开发工具（For Oracle,c#），连接数据库可以快速生成实体类、实体操作方法、对象取值、赋值方法、webform源码、并且可以快速浏览数据对象，对符合规范的代码设置还可以快速查看数据库代码值
DAO及其实现类
博客的博客
04-01 736
DAO Data Access Object 访问数据信息的类和接口 包括了对数据的CRUD（Create、Retrival、Update、 Delete） 不包含任何业务相关的信息。 有时也称作：BaseDAO 🐟作用 为了实现功能的模块化，更有利于代码的维护和升级。 一、BaseDAO.java import util.JDBCUtils; import java.lang.reflect.Field; import java.sql.*; import java.util.Ar..
关于框架Mybatis------浅谈Dao层实现和深入配置
S_yyuan的博客
04-15 612
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。
6.DAO及其相关实现类
迷路的小绅士之家
06-22 894
DAO（Data Access Object）是一种设计模式，用于将业务逻辑和数据访问逻辑分离。它将对数据的访问封装在一个单独的对象中，使得业务逻辑和数据访问逻辑分离，从而提高代码的可重用性和可维护性。
Java中DAO代码实现示例
十三月的博客
05-08 907
代码结构 DAO类 package fanxing; import java.util.*; public class DAO<T> { private Map<String,T> map = new HashMap<>();//后面<>不写，类型自动推断 // 保存T类型的对象到Map成员变量中 public void save(String id,T entity){ map.put(id,entit
java中的Dao模式及其案例
qq_40236282的博客
11-26 1966
1.什么是Dao（data access object）模式 Dao模式就是对数据库中属性及其对属性操作的分装， 一个典型的Dao操作应该包括： 1.VO:对属性的分装，将一个数据库表格中的所有的属性分装到一个类中。值对象 2.Dao实现类： 3.Dao接口：对属性操作的封装，例如：CURD（增删改查）（这个可以不写采用的优势是可以解耦） 4.Dao工厂：用来创建Dao对象。 2.采用Dao模式的...
Java中DAO的实现
热门推荐
aabbyyz的博客
11-10 1万+
Java中DAO的实现
一个的DAO数据访问层的实现
suyijianke的博客
09-29 527
    ＤＡＯ数据库操作类实现在配置文件中的工厂化管理 一、搭建 Hibernate 环境   二、创建数据库操作接口和实现类   &lt;!--[if !supportLists]--&gt;1、  &lt;!--[endif]--&gt;接口 基类接口（所有接口都继承该接口）： package fr.itris.glips.d...
baomidou 分页 dao接口示例
最新发布
07-14
下面是一个示例展示如何在 MyBatis-Plus 中使用 `baomidou` 进行分页的 DAO 接口定义： ```java import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.example.entity.User; public interface UserDao extends BaseMapper<User> { /** * 自定义分页查询方法 * @param page 分页参数 * @return 分页结果 */ IPage<User> selectUserPage(Page<User> page); } ``` 在上述示例中，`UserDao` 继承了 `BaseMapper<User>`，该接口提供了一些基本的 CRUD 方法。然后，我们自定义了一个 `selectUserPage` 方法，用于实现自定义的分页查询。 在具体的实现类中，可以使用 MyBatis-Plus 提供的 `selectPage` 方法来进行分页查询： ```java import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.example.dao.UserDao; import com.example.entity.User; import com.example.service.UserService; import org.springframework.stereotype.Service; @Service public class UserServiceImpl extends ServiceImpl<UserDao, User> implements UserService { @Override public IPage<User> selectUserPage(Page<User> page) { return baseMapper.selectUserPage(page); } } ``` 在上述示例中，`UserServiceImpl` 实现了自定义的 `selectUserPage` 方法，通过调用 `baseMapper.selectUserPage(page)` 实现了分页查询。 这样，你就可以在业务层调用 `selectUserPage` 方法来进行分页查询了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值