JDBC的DAO形式

最新推荐文章于 2023-04-11 20:40:00 发布
最新推荐文章于 2023-04-11 20:40:00 发布
阅读量359 收藏
点赞数 1
分类专栏： # JDBC 文章标签： JDBC DAO Java CRUD Junit4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43164662/article/details/121613400
版权
本文介绍了如何使用Java JDBC实现DAO（数据访问对象）模式，包括BaseDAO抽象类的设计，自定义CRUD操作，以及针对Customer表的CustomerDAO接口和实现。BaseDAO提供了通用的查询和修改方法，CustomerDAO实现了增删改查功能，并通过JUnit4进行了测试。
摘要由CSDN通过智能技术生成

DAO

前言

把最统一的查询和修改（统一增删更新）操作封装到BaseDAO抽象类中，其它表操作可以通过继承该抽象类来实现自定义的CRUD操作。

一、BaseDAO抽象类

package com.xhu.java.jdbc.dao;

import com.xhu.java.jdbc.JDBCUtils;

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

/**
 * @function 通用功能，如查询一个或多个，修改操作，其它操作如聚集函数
 */
public abstract class BaseDAO<T> {
    private Class<T> c = null;
    //获取BaseDAO子类所继承父类BaseDAO时所给的实际泛型类型。毕竟只能new BaseDAO的子类，这里的this必然指BaseDAO子类对象。这个抽象类无法new出对象
    {
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramT = (ParameterizedType) genericSuperclass;
        c = (Class<T>) paramT.getActualTypeArguments()[0];
    }

    /**
     * @param conn 一个事务的连接
     * @param sql
     * @param args
     * @return
     * @throws Exception
     * @function 获取多条记录, 通用与所有类型
     */
    public List<T> getMultiInstance(Connection conn, String sql, Object... args) {
        //1.初始化
        PreparedStatement ps = null;
        ResultSet res = null;
        //返回结果
        List<T> resList = new ArrayList<>();
        try {
            //2.获取预处理SQL对象
            ps = conn.prepareStatement(sql);
            //3.占位符赋值
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            //4.执行SQL
            res = ps.executeQuery();
            //5.处理结果集
            /**
             * @Reflect
             * res将查询出数据的字段数据即元数据信息封装在Meta-Data中
             * 获取元数据，再获取查询的列数以及字段名
             * 通过res获取字段的对应值
             * 通过反射+字段名把对应值动态注入进去
             */

            while (res.next()) {
                ResultSetMetaData metaData = res.getMetaData();
                int cCount = metaData.getColumnCount();
                T t = c.getConstructor(null).newInstance();
                //反射注入需要的class对象
                Class cusC = t.getClass();
                for (int i = 0; i < cCount; i++) {
                    //获取字段名
                    String columnName = metaData.getColumnLabel(i + 1);//获取别名对应POJO类，如果没有别名就是原名
                    Object columnValue = res.getObject(i + 1);
                    //反射实现动态注入数据
                    //获取任意权限的字段
                    Field field = cusC.getDeclaredField(columnName);
                    //获取private的权限
                    field.setAccessible(true);
                    //设置属性值
                    field.set(t, columnValue);
                }
                resList.add(t);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6.关闭资源,用于事务，不能关闭连接资源，让所有SQL处理串在一个连接里面。
            JDBCUtils.closeQuery(ps, null, res);
        }

        //7.返回查询结果
        return resList;
    }

    /**
     * @param conn 一个事务的连接
     * @param sql
     * @param args
     * @return T
     * @throws Exception
     * @function 各种类的通用查询
     */
    public T getInstance(Connection conn, String sql, Object... args) {
        //1.不用获取对象，传入一个事务的conn
        //2.获取预处理SQL对象
        PreparedStatement ps = null;
        ResultSet res = null;
        T t = null;
        try {
            ps = conn.prepareStatement(sql);
            //3.占位符赋值
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            //4.执行SQL
            res = ps.executeQuery();
            //5.处理结果集
            /**
             * @Reflect
             * res将查询出数据的字段数据即元数据信息封装在Meta-Data中
             * 获取元数据，再获取查询的列数以及字段名
             * 通过res获取字段的对应值
             * 通过反射+字段名把对应值动态注入进去
             */
            if (res.next()) {
                ResultSetMetaData metaData = res.getMetaData();
                int cCount = metaData.getColumnCount();
                t = c.getConstructor(null).newInstance();
                //反射注入需要的class对象
                Class cusC = t.getClass();
                for (int i = 0; i < cCount; i++) {
                    //获取字段名
                    String columnName = metaData.getColumnLabel(i + 1);//获取别名对应POJO类，如果没有别名就是原名
                    Object columnValue = res.getObject(i + 1);
                    //反射实现动态注入数据
                    String setMethodName = "set" + (char) (columnName.charAt(0) - 32) + columnName.substring(1);
                    String getMethodName = "get" + (char) (columnName.charAt(0) - 32) + columnName.substring(1);
                    Method method = cusC.getDeclaredMethod(setMethodName, cusC.getDeclaredMethod(getMethodName, null).getReturnType());
                    method.invoke(t, columnValue);
                    /**
                     * 方式二
                     * //获取任意权限的字段
                     * Field field = cusC.getDeclaredField(columnName);
                     * //获取private的权限
                     * field.setAccessible(true);
                     * //设置属性值
                     * field.set(cus, columnName);
                     */

                }
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        } finally {
            //6.关闭资源,将一个事务的SQL串在一个连接里，不能关闭SQL
            JDBCUtils.closeQuery(ps, null, res);
        }
        //7.返回查询结果
        return t;
    }

    /**
     * @param conn 一个事务的连接
     * @param sql  要执行的SQL语句
     * @param args SQL中要填充的参数
     * @function 增删改统一操作
     */
    public void update(Connection conn, String sql, Object... args) {
        //1.初始化
        PreparedStatement ps = null;
        try {
            //2.通过连接+sql得到一个把SQL语句预编译的操作SQL对象PreparedStatement
            ps = conn.prepareStatement(sql);
            //3.为预编译的SQL中占位符设置数值
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            //4.执行SQL
            ps.execute();
        } catch (Exception e) {
            System.out.println("插入异常");
            e.printStackTrace();
        } finally {
            //5.关闭连接,连接资源不可关闭，将所有SQL串在一个连接中。
            JDBCUtils.close(ps, null);
        }
    }

    /**
     * @param conn
     * @param sql
     * @param args
     * @param <T>
     * @return
     * @function 用于获取聚集函数的值
     */
    public <T> T getValue(Connection conn, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet res = null;
        try {
            //1.获取操作SQL对象
            ps = conn.prepareStatement(sql);
            //2.设置参数
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            //3.执行SQL并获取结果集
            res = ps.executeQuery();
            //4.处理结果集
            if (res.next()) {
                return (T) res.getObject(1);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.closeQuery(ps, null, res);
        }
        return null;
    }

}

二、自定义CRUD

1、Customer

package com.xhu.java.jdbc.pojo;

import java.sql.Date;

/*
 * ORM编程思想  （object relational mapping）
 * 一个数据表对应一个java类
 * 表中的一条记录对应java类的一个对象
 * 表中的一个字段对应java类的一个属性
 * 
 */
public class Customer {
	
	private int id;
	private String name;
	private String email;
	private Date birth;
	public Customer() {
		super();
	}
	public Customer(int id, String name, String email, Date birth) {
		super();
		this.id = id;
		this.name = name;
		this.email = email;
		this.birth = birth;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	@Override
	public String toString() {
		return "Customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
	}
	
	
	
}

2、CustomerDAO接口

package com.xhu.java.jdbc.dao;

import com.xhu.java.jdbc.pojo.Customer;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

/**
 * @definition 定义Customer表的一组规范。
 */
public interface CustomerDAO {
    /**
     * @param conn
     * @param cus
     * @definition 定义增加
     */
    void insert(Connection conn, Customer cus);

    /**
     * @param conn
     * @param id
     * @dfinition 定义删除操作，根据id删除一条记录
     */
    void delete(Connection conn, int id);

    /**
     * @param conn
     * @param cus
     * @definition 定义修改操作，根据cus中的id来修改一条记录。
     */
    void update(Connection conn, Customer cus);

    /**
     * @param conn
     * @param id
     * @return
     * @definition 定义获取一个指定的Customer，根据id来获取
     */
    Customer getCustomerById(Connection conn, int id);

    /**
     * @param conn
     * @return
     * @definition 定义获取所有Customer
     */
    List<Customer> getAll(Connection conn);

    /**
     * @param conn
     * @return
     * @function 获取一共多少条记录
     */
    long getCount(Connection conn);

    /**
     * @param conn
     * @return
     * @function 获取谁最晚出生
     */
    Date getMaxbirth(Connection conn);
}

3、DAO实现

package com.xhu.java.jdbc.dao.impl;

import com.xhu.java.jdbc.dao.BaseDAO;
import com.xhu.java.jdbc.dao.CustomerDAO;
import com.xhu.java.jdbc.pojo.Customer;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

public class CustomerDAOImpl extends BaseDAO<Customer> implements CustomerDAO {
    @Override
    public void insert(Connection conn, Customer cus) {
        String sql = "insert into customers(`name`,email,birth) values(?,?,?)";
        update(conn, sql, cus.getName(), cus.getEmail(), cus.getBirth());
    }

    @Override
    public void delete(Connection conn, int id) {
        String sql = "delete from customers where id = ?";
        update(conn, sql, id);
    }

    @Override
    public void update(Connection conn, Customer cus) {
        String sql = "update customers set `name` = ?,email = ?,birth = ? where id = ?";
        update(conn, sql, cus.getName(), cus.getEmail(), cus.getBirth(), cus.getId());
    }

    @Override
    public Customer getCustomerById(Connection conn, int id) {
        String sql = "select id,`name`,email,birth from customers where id = ?";
        return getInstance(conn, sql, id);
    }

    @Override
    public List<Customer> getAll(Connection conn) {
        String sql = "select id,`name`,email,birth from customers";
        return getMultiInstance(conn, sql);
    }

    @Override
    public long getCount(Connection conn) {
        String sql = "select count(1) from customers";
        return getValue(conn, sql);
    }

    @Override
    public Date getMaxbirth(Connection conn) {
        String sql = "select max(birth) from customers";
        return getValue(conn, sql);
    }
}

4、Junit4测试

package test.com.xhu.java.jdbc.dao.impl;

import com.xhu.java.jdbc.JDBCUtils;
import com.xhu.java.jdbc.dao.impl.CustomerDAOImpl;
import com.xhu.java.jdbc.pojo.Customer;
import org.junit.Test;
import org.junit.Before;
import org.junit.After;

import java.sql.Connection;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.List;

/**
 * CustomerDAOImpl Tester.
 *
 * @author <Authors name>
 * @version 1.0
 * @since <pre>11 29, 2021</pre>
 */
public class CustomerDAOImplTest {
    private CustomerDAOImpl dao = new CustomerDAOImpl();
    private Connection conn = null;

    @Before
    public void before() throws Exception {
    }

    @After
    public void after() throws Exception {
    }

    /**
     * Method: insert(Connection conn, Customer cus)
     */
    @Test
    public void testInsert() throws Exception {
        conn = JDBCUtils.getConn();
        dao.insert(conn, new Customer(1, "李某", "lm@qq.com", new Date(new SimpleDateFormat("yyyy-MM-dd").parse("1998-9-9").getTime())));
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: delete(Connection conn, int id)
     */
    @Test
    public void testDelete() throws Exception {
        conn = JDBCUtils.getConn();
        dao.delete(conn, 20);
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: update(Connection conn, Customer cus)
     */
    @Test
    public void testUpdate() throws Exception {
        conn = JDBCUtils.getConn();
        dao.update(conn, new Customer(20, "王某", "wm@qq.com", new Date(new SimpleDateFormat("yyyy-MM-dd").parse("1998-9-9").getTime())));
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: getCustomerById(Connection conn, int id)
     */
    @Test
    public void testGetCustomerById() throws Exception {
        conn = JDBCUtils.getConn();
        Customer cus = dao.getCustomerById(conn, 1);
        System.out.println(cus);
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: getAll(Connection conn)
     */
    @Test
    public void testGetAll() throws Exception {
        conn = JDBCUtils.getConn();
        List<Customer> cus = dao.getAll(conn);
        cus.forEach(System.out::println);
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: getCount(Connection conn)
     */
    @Test
    public void testGetCount() throws Exception {
        conn = JDBCUtils.getConn();
        long count = dao.getCount(conn);
        System.out.println(count);
        JDBCUtils.close(null, conn);
    }

    /**
     * Method: getMaxbirth(Connection conn)
     */
    @Test
    public void testGetMaxbirth() throws Exception {
        conn = JDBCUtils.getConn();
        Date date = dao.getMaxbirth(conn);
        System.out.println(date);
        JDBCUtils.close(null, conn);
    }


}

总结

1）BaseDAO抽象类封装公共操作
2）各个表的DAO自定义CRUD
3）Junnit4测试，setting中plugins install JunitGuide，然后右键类generate Test类。

参考文献

[1] JDBC 尚硅谷（含SQL文件和各种资料）
[2] 自动生成测试类 百度知道
[3] Idea 添加Junit4的三种方法

REN_林森
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC中DAO+service设计思想
含江君
09-12 1674
一.DAO设计思想 a) Data access Object（数据访问对象）：前人总结出的一种固定模式的设计思想。   高可读性、   高复用性、   高扩展性、 b) JDBC代码实现的增删改查操作是有复用需求的。所以需要将对数据库的增删改查操作进行封装。 c) DAO类：特殊类。只对对数据库进行CRUD（增删改查）的操作进行具体的封装。 d) 注意：DAO类的个数取决于ta
JDBC之DAO设计
pcsd的博客
06-14 642
一、DAO介绍l DAO（数据访问对象）的主要功能是数据操作；l 使用DAO设计模式，来封装数据库持久层的所有操作，使得低级的数据逻辑和高级的业务逻辑分离，达到解耦合的目的了；l 在程序开发的结构中属于数据层的操作；l 程序开发的标准架构如下： l 客户层、显示层、业务层和数据层分别介绍如下：(1)客户层：现在都采用B/S开发架构，一般用户都使用浏览器进行访问，当然也可以采用其他程序进行访问；(2...
JDBC之DAO
zhouhe_的博客
06-11 972
JDBC准备工作 下载 mysql-connector-java-8.0.25.jar 官网下载地址：https://dev.mysql.com/downloads/connector/j/ 下载mysql对应版本的 创建项目，在项目下创建lib文件夹，把 mysql-connector-java-8.0.25.jar添加到lib文件夹中 然后再src中正常创建包，就可以写JDBC 有关代码了 可以在mysql中查看连接数量： ​ 可以让程序先睡几秒，然后mysql客户端执行 sh
jdbc中首次了解DAO及其子类
qq_45554909的博客
12-19 128
/* DAO: data(base) access object 封装了针对于数据表的通用的操作 */ public abstract class BaseDAO { private Class clazz = null; // public BaseDAO(){ // // } { //获取当前BaseDAO的子类继承的父类中的泛型 Type genericSuperclass = this.getClass().getGenericSuperclass(); Parameteri
JDBC---DAO模式
shall潇の菜园
03-08 432
JDBC—（二） 前言：之前讲的JDBC由于要反复创建连接、关闭资源等，很是麻烦，所以在之前的基础上，我们优化一下，利用接口、实现类和配置文件来实现JDBC 【注意：以下代码可能有先后顺序】 dao层 package dao; public interface BaseDao { //声明一些会经常使用的方法 void getConn(String Driver,String url,String username,String passwd); //创键连接 void quer
名片管理系统——Struts2+JDBC+DAO.zip
01-11
增加名片：以仿真的形式增加名片信息 修改名片：以仿真的形式修改名片信息 查询名片：以模糊查询方式查询名片 删除名片：将名片移到回收站或者把名片彻底删除 3回收站管理 还原：将回收站里面的名片还原回收 ...
Java使用JDBC连接postgresql数据库示例
08-26
描述：主要介绍了 Java 使用 JDBC 连接 PostgreSQL 数据库，结合实例形式分析了 JDBC 连接 PostgreSQL 数据库及数值插入、更新、查询等相关操作技巧。 标签：Java JDBC 连接 PostgreSQL 数据库 详细解释： 1. ...
dao包封装包
03-24
这些方法通常以抽象形式存在，不包含具体的SQL语句。例如，一个`UserDAO`接口可能包含如下方法： ```java public interface UserDAO { void addUser(User user); User getUserById(int id); List<User> getAll...
jdbc笔记(自写)
10-31
Day1–JDBC概述+JDBC完成CRUD+DAO设计 1.JDBC概述 1.1 什么是持久化(persistence): 持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。 ​ 保存数据: ​ 内存中: 掉电之后,数据就没了. ​ 磁盘...
万能javaDAO
07-11
- **JDBC**：Java数据库连接，是Java访问数据库的基础，提供了与数据库交互的API。 - **SQL**：结构化查询语言，用于操作数据库，包括选择、插入、更新和删除数据等操作。 - **ORM**：对象关系映射，如Hibernate...
JDBC_DAO模式
DanBo_C的博客
06-24 691
包结构 src dao UserDao.java dao.impl UserDaoimpl.java util JDBCUtil.java test Test.java jdbc.properties.txt lib mysql-connector-java-bin.jar 完整代码 jdbc.properties #mysql driverClass ...
学习JDBC的Dao模式
m0_55640070的博客
03-31 512
学习JDBC的Dao模式。
(4. JDBC的DAO模式)
m0_56379670的博客
09-22 418
DAO是一个操作数据库的设计模式(DAO是一种访问数据库的设计模式，大概的思路就是将对一个数据库（和一个数据表）的操作封装到一个类中，由其他的类来调用这个类的方法完成对数据库的操作，这样可以简化负责业务处理的类的复杂性和耦合性)一个Dao模式应该包含以下几点：1：VO:Value Object 创建一个类，该类中只有属性值，并且属性值对应数据表中的所有字段2：Dao接口：Data Access Object 这是一个接口，接口中有对数据库进行操作的方法。
JDBC（DAO及相关实现类）
qingmenghan的博客
11-04 153
七DAO及相关实现类 DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO 作用: 为了实现功能的模块化，更有利于代码的维护和升级。 用BaseDAO，BookDAO和BookDaoImpl案例来结合理解 Book 图书实体类 package com.atguigu.bookstore.beans; /** * ..
简单学习 JDBC的DAO模式
Dearan33的博客
10-29 6479
JDBC操作数据库Dao模式的简单设计
1.3 JDBC的dao模式,初步了解dao模式，使用dao模式完成jdbc的增删改查(重点)
世上哪有什么岁月静好,不过是有人替你负重前行
12-10 1863
Dao模式 Dao模式：就是避免项目的逻辑代码和sql代码在一块书写，一个方法的工作量过于庞大，冗余代码还比较多： 逻辑代码和sql代码分离：Service业务逻辑层+Dao持久层 使用DAO模式进行项目开发主要有以下两个好处： 隔离了业务逻辑代码和数据访问代码，分工明确，降低耦合性，提高可重用性。 采用面向接口编程，提高了项目的可扩展性和可维护性。 一个典型的DAO模式主要有以下几部分组成: 1、DAO接口： 把对数据库的所有操作定义成抽象方法，可以提供多种实现。 2、DAO 实现类： 针对不同数据
【JDBC】-- DAO实现操作数据库
张修宇的博客
07-27 2225
DAO（DataAccessObject）访问数据信息的类和接口，包括对数据的CRUD，而不包含任何业务相关的信息。
JDBC中DAO模式的例子示范
李昆鹏的博客
06-15 2019
----------------------------------------JDBC中DAO模式的例子示范---------------------------------------1　JdbcUtils的作用你也看到了，连接数据库的四大参数是：驱动类、url、用户名，以及密码。这些参数都与特定数据库关联，如果将来想更改数据库，那么就要去修改这四大参数，那么为了不去修改代码，我们写一个Jdb...
JDBC之DAO层封装思想超详解
最新发布
siaok的博客
04-11 1009
dbutils，全称commons-dbutils，它 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。其中QueryRunner类封装了SQL的执行，是线程安全的。可以实现增、删、改、查、批处理。考虑了事务处理需要共用Connection。该类最主要的就是简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值