DAO 相关

概念

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

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

使用

表结构：

DAO使用：

  1. package cn.parzulpan.jdbc.ch07.util;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  4. import org.apache.commons.dbutils.DbUtils;
  6. import javax.sql.DataSource;
  7. import java.io.InputStream;
  8. import java.sql.*;
  9. import java.text.ParseException;
  10. import java.text.SimpleDateFormat;
  11. import java.util.Properties;
  13. /**
  14.  * @Author : parzulpan
  15.  * @Time : 2020-12-02
  16.  * @Desc : 操作数据库的工具类，最终版
  17.  */
  19. public class JDBCUtils {
  20.     private static DataSource dataSource = null;
  22.     static {
  23.         try {
  24.             Properties properties = new Properties();
  25.             InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
  26.             properties.load(is);
  27.             dataSource = DruidDataSourceFactory.createDataSource(properties);
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  33.     /**
  34.      * 获取数据库连接，使用 Druid 数据库连接池
  35.      * @return 数据库连接
  36.      */
  37.     public static Connection getDruidConnection() throws SQLException {
  38.         return dataSource.getConnection();
  39.     }
  41.     /**
  42.      * 使用DbUtils，静默关闭数据库资源
  43.      * @param connection 数据库连接
  44.      * @param statement 声明
  45.      * @param resultSet 结果集
  46.      */
  47.     public static void closeResourceQuietly(Connection connection, Statement statement, ResultSet resultSet) {
  48.         DbUtils.closeQuietly(connection);
  49.         DbUtils.closeQuietly(statement);
  50.         DbUtils.closeQuietly(resultSet);
  51.     }
  53.     public static Date getSqlDate(String dateStr) {
  54.         java.sql.Date date = null;
  55.         try {
  56.             java.util.Date parse = new SimpleDateFormat("yyyy-MM-dd").parse(dateStr);
  57.             date = new java.sql.Date(parse.getTime());
  58.         } catch (ParseException e) {
  59.             e.printStackTrace();
  60.         }
  61.         return date;
  62.     }
  63. }
  1. package cn.parzulpan.jdbc.ch07.dao;
  3. import org.apache.commons.dbutils.QueryRunner;
  4. import org.apache.commons.dbutils.handlers.BeanHandler;
  5. import org.apache.commons.dbutils.handlers.BeanListHandler;
  6. import org.apache.commons.dbutils.handlers.ScalarHandler;
  8. import java.lang.reflect.ParameterizedType;
  9. import java.lang.reflect.Type;
  10. import java.sql.Connection;
  11. import java.sql.SQLException;
  12. import java.util.List;
  14. /**
  15.  * @Author : parzulpan
  16.  * @Time : 2020-12-01
  17.  * @Desc : 对数据表的通用操作
  18.  */
  20. public abstract class BaseDAO<T> {
  21.     // 泛型的类型
  22.     private Class<T> type;
  23.     private QueryRunner queryRunner = new QueryRunner();
  25.     // 获取 T 类对象，获取泛型的类型，泛型是在被子类继承时才确定的
  26.     public BaseDAO() {
  27.         // 获取子类的类型
  28.         Class<? extends BaseDAO> clazz = this.getClass();
  30.         // 获取父类的类型
  31.         ParameterizedType parameterizedType = (ParameterizedType) clazz.getGenericSuperclass();
  33.         // 获取具体的泛型
  34.         Type[] types = parameterizedType.getActualTypeArguments();
  36.         this.type = (Class<T>)types[0];
  37.     }
  39.     /**
  40.      * 通用的增删改操作
  41.      * @param connection 数据库连接
  42.      * @param sql   sql 语句
  43.      * @param args 参数
  44.      * @return 更新的条数
  45.      */
  46.     public int update(Connection connection, String sql, Object ... args) {
  47.         int update = 0;
  48.         try {
  49.             update = queryRunner.update(connection, sql, args);
  50.         } catch (SQLException e) {
  51.             e.printStackTrace();
  52.         }
  53.         return update;
  54.     }
  56.     /**
  57.      * 通用的查询操作
  58.      * @param connection 数据库连接
  59.      * @param sql   sql 语句
  60.      * @param args 参数
  61.      * @return 返回一个对象
  62.      */
  63.     public T getBean(Connection connection, String sql, Object ... args) {
  64.         T t = null;
  65.         BeanHandler<T> beanHandler = new BeanHandler<>(type);
  66.         try {
  67.             t = queryRunner.query(connection, sql, beanHandler, args);
  68.         } catch (SQLException e) {
  69.             e.printStackTrace();
  70.         }
  71.         return t;
  72.     }
  74.     /**
  75.      * 通用的查询操作
  76.      * @param connection 数据库连接
  77.      * @param sql   sql 语句
  78.      * @param args 参数
  79.      * @return 返回一个对象列表
  80.      */
  81.     public List<T> getBeanList(Connection connection, String sql, Object ... args) {
  82.         List<T> list = null;
  83.         BeanListHandler<T> beanListHandler = new BeanListHandler<>(type);
  84.         try {
  85.             list = queryRunner.query(connection, sql, beanListHandler, args);
  86.         } catch (SQLException e) {
  87.             e.printStackTrace();
  88.         }
  89.         return list;
  90.     }
  92.     /**
  93.      * 查询特殊值，类似于最大的，最小的，平均的，总和，个数相关的操作
  94.      * @param connection 数据库连接
  95.      * @param sql   sql 语句
  96.      * @param args 参数
  97.      * @return 特殊值
  98.      */
  99.     public Object getValue(Connection connection, String sql, Object ... args) {
  100.         Object obj = null;
  101.         ScalarHandler scalarHandler = new ScalarHandler();
  102.         try {
  103.             obj = queryRunner.query(connection, sql, scalarHandler, args);
  104.         } catch (SQLException e) {
  105.             e.printStackTrace();
  106.         }
  107.         return obj;
  108.     }
  109. }
  1. package cn.parzulpan.jdbc.ch07.dao;
  3. import cn.parzulpan.jdbc.ch07.bean.Customer;
  5. import java.sql.Connection;
  6. import java.sql.Date;
  7. import java.util.List;
  9. /**
  10.  * @Author : parzulpan
  11.  * @Time : 2020-12-01
  12.  * @Desc : 此接口用于规范 customers 表的常用操作
  13.  */
  15. public interface CustomerDAO {
  17.     /**
  18.      * 将 customer 对象添加到数据库中
  19.      * @param connection 数据库连接
  20.      * @param customer customer 对象
  21.      */
  22.     void insert(Connection connection, Customer customer);
  24.     /**
  25.      * 用 customer 对象修改数据库对应的数据中
  26.      * @param connection 数据库连接
  27.      * @param customer customer 对象
  28.      */
  29.     void update(Connection connection, Customer customer);
  31.     /**
  32.      * 根据 Id 删除一条记录
  33.      * @param connection 数据库连接
  34.      * @param id
  35.      */
  36.     void deleteById(Connection connection, int id);
  38.     /**
  39.      * 根据 Id 查询一条记录
  40.      * @param connection 数据库连接
  41.      * @param id
  42.      * @return
  43.      */
  44.     Customer getCustomerById(Connection connection, int id);
  46.     /**
  47.      * 查询多条记录
  48.      * @param connection 数据库连接
  49.      * @return
  50.      */
  51.     List<Customer> getCustomerList(Connection connection);
  53.     /**
  54.      * 查询记录条数
  55.      * @param connection 数据库连接
  56.      * @return
  57.      */
  58.     Long getCount(Connection connection);
  60.     /**
  61.      * 查询最大的生日记录
  62.      * @param connection 数据库连接
  63.      * @return
  64.      */
  65.     Date getMaxBirth(Connection connection);
  67. }
  1. package cn.parzulpan.jdbc.ch07.impl;
  3. import cn.parzulpan.jdbc.ch07.bean.Customer;
  4. import cn.parzulpan.jdbc.ch07.dao.BaseDAO;
  5. import cn.parzulpan.jdbc.ch07.dao.CustomerDAO;
  7. import java.sql.Connection;
  8. import java.sql.Date;
  9. import java.util.List;
  11. /**
  12.  * @Author : parzulpan
  13.  * @Time : 2020-12-01
  14.  * @Desc :
  15.  */
  17. public class CustomerDAOImpl extends BaseDAO<Customer> implements CustomerDAO {
  18.     /**
  19.      * 将 customer 对象添加到数据库中
  20.      *
  21.      * @param connection 数据库连接
  22.      * @param customer   customer 对象
  23.      */
  24.     @Override
  25.     public void insert(Connection connection, Customer customer) {
  26.         String sql = "insert into customers(name, email, birth)values(?,?,?)";
  27.         update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth());
  28.     }
  30.     /**
  31.      * 用 customer 对象修改数据库对应的数据中
  32.      *
  33.      * @param connection 数据库连接
  34.      * @param customer   customer 对象
  35.      */
  36.     @Override
  37.     public void update(Connection connection, Customer customer) {
  38.         String sql = "update customers set name = ?, email = ?, birth = ? where id = ?";
  39.         update(connection, sql, customer.getName(), customer.getEmail(), customer.getBirth(), customer.getId());
  40.     }
  42.     /**
  43.      * 根据 Id 删除一条记录
  44.      *
  45.      * @param connection 数据库连接
  46.      * @param id
  47.      */
  48.     @Override
  49.     public void deleteById(Connection connection, int id) {
  50.         String sql = "delete from customers where id = ?";
  51.         update(connection, sql, id);
  52.     }
  54.     /**
  55.      * 根据 Id 查询一条记录
  56.      *
  57.      * @param connection 数据库连接
  58.      * @param id
  59.      * @return
  60.      */
  61.     public Customer getCustomerById(Connection connection,  int id) {
  62.         String sql = "select id, name, email, birth from customers where id = ?";
  63.         return getBean(connection, sql, id);
  64.     }
  66.     /**
  67.      * 查询多条记录
  68.      *
  69.      * @param connection 数据库连接
  70.      * @return
  71.      */
  72.     @Override
  73.     public List<Customer> getCustomerList(Connection connection) {
  74.         String sql = "select id, name, email, birth from customers";
  75.         return getBeanList(connection, sql);
  76.     }
  78.     /**
  79.      * 查询记录条数
  80.      *
  81.      * @param connection 数据库连接
  82.      * @return
  83.      */
  84.     @Override
  85.     public Long getCount(Connection connection) {
  86.         String sql = "select count(*) from customers";
  87.         return (Long) getValue(connection, sql);
  88.     }
  90.     /**
  91.      * 查询最大的生日记录
  92.      *
  93.      * @param connection 数据库连接
  94.      * @return
  95.      */
  96.     @Override
  97.     public Date getMaxBirth(Connection connection) {
  98.         String sql = "select max(birth) from customers";
  99.         return (Date) getValue(connection, sql);
  100.     }
  101. }
  1. package cn.parzulpan.jdbc.ch07.junit;
  3. import cn.parzulpan.jdbc.ch07.bean.Customer;
  4. import cn.parzulpan.jdbc.ch07.impl.CustomerDAOImpl;
  5. import cn.parzulpan.jdbc.ch07.util.JDBCUtils;
  6. import org.junit.After;
  7. import org.junit.Before;
  8. import org.junit.Test;
  10. import java.sql.Connection;
  11. import java.sql.Date;
  12. import java.sql.SQLException;
  13. import java.util.List;
  15. import static org.junit.Assert.*;
  17. /**
  18.  * @Author : parzulpan
  19.  * @Time : 2020-12-02
  20.  * @Desc :
  21.  */
  23. public class CustomerDAOImplTest {
  25.     @Before
  26.     public void setUp() throws Exception {
  27.         System.out.println("CustomerDAOImplTest Before");
  28.     }
  30.     @After
  31.     public void tearDown() throws Exception {
  32.         System.out.println("CustomerDAOImplTest Down");
  33.     }
  35.     private CustomerDAOImpl customerDAO = new CustomerDAOImpl();
  37.     @Test
  38.     public void insert() {
  39.         Connection connection = null;
  40.         try {
  41.             connection = JDBCUtils.getDruidConnection();
  42.             Customer customer = new Customer(30, "DAO", "dao@163.com", JDBCUtils.getSqlDate("1995-1-1"));
  43.             customerDAO.insert(connection, customer);
  44.         } catch (SQLException e) {
  45.             e.printStackTrace();
  46.         } finally {
  47.             JDBCUtils.closeResourceQuietly(connection, null, null);
  48.         }
  49.     }
  51.     @Test
  52.     public void update() {
  53.         Connection connection = null;
  54.         try {
  55.             connection = JDBCUtils.getDruidConnection();
  56.             Customer customer = new Customer(24, "DAOUpdate", "dao@163.com", JDBCUtils.getSqlDate("1995-1-1"));
  57.             customerDAO.update(connection, customer);
  58.         } catch (SQLException e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             JDBCUtils.closeResourceQuietly(connection, null, null);
  62.         }
  63.     }
  65.     @Test
  66.     public void deleteById() {
  67.         Connection connection = null;
  68.         try {
  69.             connection = JDBCUtils.getDruidConnection();
  70.             customerDAO.deleteById(connection, 23);
  71.         } catch (SQLException e) {
  72.             e.printStackTrace();
  73.         } finally {
  74.             JDBCUtils.closeResourceQuietly(connection, null, null);
  75.         }
  76.     }
  78.     @Test
  79.     public void getCustomerById() {
  80.         Connection connection = null;
  81.         try {
  82.             connection = JDBCUtils.getDruidConnection();
  83.             Customer customer = customerDAO.getCustomerById(connection, 10);
  84.             System.out.println(customer);
  85.         } catch (SQLException e) {
  86.             e.printStackTrace();
  87.         } finally {
  88.             JDBCUtils.closeResourceQuietly(connection, null, null);
  89.         }
  90.     }
  92.     @Test
  93.     public void getCustomerList() {
  94.         Connection connection = null;
  95.         try {
  96.             connection = JDBCUtils.getDruidConnection();
  97.             List<Customer> customers = customerDAO.getCustomerList(connection);
  98.             customers.forEach(System.out::println);
  99.         } catch (SQLException e) {
  100.             e.printStackTrace();
  101.         } finally {
  102.             JDBCUtils.closeResourceQuietly(connection, null, null);
  103.         }
  104.     }
  106.     @Test
  107.     public void getCount() {
  108.         Connection connection = null;
  109.         try {
  110.             connection = JDBCUtils.getDruidConnection();
  111.             Long count = customerDAO.getCount(connection);
  112.             System.out.println(count);
  113.         } catch (SQLException e) {
  114.             e.printStackTrace();
  115.         } finally {
  116.             JDBCUtils.closeResourceQuietly(connection, null, null);
  117.         }
  118.     }
  120.     @Test
  121.     public void getMaxBirth() {
  122.         Connection connection = null;
  123.         try {
  124.             connection = JDBCUtils.getDruidConnection();
  125.             Date maxBirth = customerDAO.getMaxBirth(connection);
  126.             System.out.println(maxBirth);
  127.         } catch (SQLException e) {
  128.             e.printStackTrace();
  129.         } finally {
  130.             JDBCUtils.closeResourceQuietly(connection, null, null);
  131.         }
  132.     }
  133. }

练习和总结

【JDBC核心】DAO 相关的更多相关文章

  1. Unit02： JDBC核心API

    Unit02: JDBC核心API db.properties 注意:如果使用连接池,可以在这个文件中增加对连接池的相关设置: 连接池参数,常用参数有: 初始连接数 最大连接数 最小连接数 每次增加的 ...

  2. 关于案例中核心dao的解释

    很多小伙伴不太理解核心dao,说这是干什么的,接下来我将一一为大家解答: 1.说到核心dao不得不说到单表操作,单表操作顾名思义是对单张数据库表的CRUD操作,实际情况中我们追求将表与表的关系映射到对 ...

  3. JDBC核心API

    JDBC核心API在java.sql.*和javax.sql.* 1.Driver接口:表示Java驱动程序接口,具体的数据库厂商要实现其此接口 connect(url.propertis):连接数据 ...

  4. [课本]JDBC课程6--使用JDBC的DAO模块化--完成数据库的增删查改_工具类JDBCTools四个(Preparedstatement)功能模块的敲定版

    (课本P273-任务九) /**DAO: Data Access Object * 为什么用: 实现功能的模块化,更有利于代码的维护和升级 * 是什么: 访问数据信息的类,包含对数据的CRUD(cre ...

  5. 关于mysql，需要掌握的基础（二）：JDBC和DAO层

    ​ 目录 关于mysql,需要掌握的基础(二):JDBC和DAO层 1.了解jdbc是什么? 2.加载注册驱动:为什么Class.forName("com.mysql.jdbc.Driver ...

  6. Java 核心内容相关面试题【3】

    目录 面向对象编程(OOP) 常见的Java问题 Java线程 Java集合类 垃圾收集器 异常处理 Java小应用程序(Applet) Swing JDBC 远程方法调用(RMI) Servlet ...

  7. Jdbc与Dao和Javabean的区别

    JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口 ...

  8. JDBC、DAO

    JDBC是Java数据库连接技术的简称,提供连接各种常用数据库的能力 JDBC的工作原理 JDBC 驱动器由数据库厂商提供 1.在个人开发与测试中,可以使用JDBC-ODBC桥连方式 2.在生产型开发 ...

  9. JDBC中DAO事务函数模版

    DAO事物函数模版1: public void OrderFinsByPage(){ Connection conn = null; PreparedStatement pstmt = null; R ...

随机推荐

  1. Object.prototype.toString.call()和typeof()区别

    js中判断数据类型都知道用tyoeof(),但是他只能判断object,boolean,function,string,number,undefined还有symbol(es6新增)这几种初步类型,比 ...

  2. webstorm2020最新安装破解教程方法永久激活码

    现在webstorm的版本已经更新到2020.3了,还没有升级的小伙伴们赶紧升级啦,本文教大家如何安装webstorm2020.3版本并且破解,此方法亲测百分百可以永久激活webstorm2020.3 ...

  3. Codeforces Edu Round 64 A-D

    A. Inscribed Figures 分类讨论打表即可. PS:这道题翻译有歧义. 这样稍微翻转一下,就可以是\(7\)个交点呀...(大概是我没看英文题干导致的惨案) #include < ...

  4. basic english

    color/visual see look color dark light beautiful shade black blue brown clear gray green orange red ...

  5. git学习——git下载安装

    原文来至 一.集中式vs分布式 Linus一直痛恨的CVS及SVN都是集中式的版本控制系统,而Git是分布式版本控制系统,集中式和分布式版本控制系统有什么区别呢? 先说集中式版本控制系统,版本库是集中 ...

  6. js日期格式化-----总结

    1. // 对Date的扩展,将 Date 转化为指定格式的String // 月(M).日(d).小时(h).分(m).秒(s).季度(q) 可以用 1-2 个占位符, // 年(y)可以用 1-4 ...

  7. Git：git常用命令

    1.版本控制工具     一个可以管理和追踪软件代码的工具.     分类:       集中式版本控制工具:SVN       分布式版本控制工具:Git 2.Git 的概念:     工作区:就是 ...

  8. idea的下载与安装

    1.下载idea.到idea的官网选择你需要下载的,你最喜欢的版本https://www.jetbrains.com/idea/download/ 2.下载jdk.进入Oracle官网,鼠标指在Dow ...

  9. 想用selenium ,先了解html 基础知识（5）

    二.HTML语法---了解!1.HTML超文本标记语言,是网页设计使用的语言.2.从<html>开始,到</html>结束,里面包括head和body两个部分,我们测试人员关心 ...

  10. Flink问题1

    flink问题1 报错: More buffers requested available than totally available 查看源码: /** * This method makes s ...