手撕JDBC笔记(含源码)，进阶框架必备

Posted 2023-02-19 stormzhuo

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撕JDBC笔记(含源码)，进阶框架必备相关的知识，希望对你有一定的参考价值。

文章目录

一、JDBC概述
二、获取数据库连接
三、PreparedStatement vs Statement
- 3.1 使用Statement操作数据表的弊端及缺点
- 3.2 PreparedStatement相比Statement的优点
四、使用PreparedStatement实现CRUD操作
五、操作BLOB类型字段
六、批量操作
- 6.1 批量处理SQL语句
- 6.2 高效的批量插入(迭代)
七、数据库事务
八、数据库连接池
九、Apache-DBUtils实现CRUD
- 9.1 主要API介绍
- - 9.2 使用DbUtils替换JDBCUtils.java关闭资源
  - 9.2 使用QueryRunner类替换通用的增删改查
十、Dao设计模式
- 使用JUnit自动生成测试类

JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等都封装了JDBC。如果只单纯使用持久层框架，可以不用学习JDBC,但从程序员发展前景来看则必须要掌握的，框架会一直迭代更新，但原理是不变的，掌握JDBC,才能以不变应完变，这样才能走的长久

一、JDBC概述

JDBC： 是sun公司提供一套用于不局限某种特定的数据库操作的接口，不同的数据库厂商，需要针对这套接口，提供不同实现(实现类)。不同的实现的集合，即为不同数据库的驱动。所以java程序员只需要面向这套接口编程即可(即面向接口编程，java代码中不应该出现第三方代码)。

例如，在标准类库中定义了java.sql,javax.sql用来访问数据库的标准Java类库，使用这些类库可以以一种标准的方法、方便地访问数据库资源。而不同的数据库厂商，需要根据这一标准实现自己的数据库操作方式(驱动)

JDBC的目的是方便操作不同的数据库，进行数据的持久化

持久化(persistence)： 把数据保存到可掉电式存储设备中以供之后使用，例如磁盘文件，XML文件，数据库

在没有JDBC时，由于不同的数据库的操作方式不同，这样每当切换数据库时，原有的Java代码就需要修改，可移植性很差，如下

有了JDBC，Java程序访问数据库时是这样的：

创建标准类库中的Driver接口的实现类(某个数据库厂商提供的驱动)对象，赋给接口对象，实现上转型
调用Driver接口的connect方法获取连接，由于多态和动态绑定，实际调用的是实现类的方法(某个数据库厂商驱动重写的connect方法)

JDBC程序编写步骤

补充：ODBC(Open Database Connectivity，开放式数据库连接)，是微软在Windows平台下推出的。使用者在程序中只需要调用ODBC API，由 ODBC 驱动程序将调用转换成为对特定的数据库的调用请求。

二、获取数据库连接

2.1 Driver接口及实现类

2.1.1 Driver接口介绍

java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。

Oracle的驱动：oracle.jdbc.driver.OracleDriver
mysql的驱动： com.mysql.jdbc.Driver

java连接数据库需现在加载数据库驱动Driver（标准类库中的Driver接口的实现类)，因此需要导入相关数据库的驱动jar包，这里已mysql为例，驱动下载地址

将上述jar包拷贝到Java工程的一个目录中，习惯上新建一个lib文件夹。

2.1.2 加载JDBC驱动(Driver实现类)

加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名

Class.forName(“com.mysql.jdbc.Driver”);

2.2 数据库五种连接方式（迭代)

连接方式一

// 方式一：
@Test
public void testConnection1() throws SQLException 
    //1.创建java.sql.Driver接口实现类的对象，并赋给接口对象driver，实现上转型
    Driver driver = new com.mysql.jdbc.Driver();
    // 2.提供url，指明具体操作的数据
    String url = "jdbc:mysql://localhost:3306/test";
    //3.提供Properties的对象，指明用户名和密码
    Properties info = new Properties();
    info.setProperty("user", "root");
    info.setProperty("password", "12345");
    //4.调用driver的connect()，获取连接
    Connection connect = driver.connect(url, info);
    System.out.println(connect);

方式一中显式出现了第三方数据库的API，数据库相关数据硬编码在代码中，耦合性大，每当切换数据库驱动或修改数据时，就需要修改源代码

连接方式二

// 方式二：对方式一的迭代:在如下的程序中不出现第三方的api,使得程序具有更好的可移植性
@Test
public void testConnection2() throws Exception 
    // 1.使用反射，加载Driver实现类对象：
    Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
    // 2.创建驱动(实现类)对象
    Driver driver = (Driver) aClass.newInstance();
    String url = "jdbc:mysql://localhost:3306/test";
    String user= "root";
    String password = "12345";
    Properties info = new Properties();
    info.setProperty("user", user);
    info.setProperty("password", password);
    Connection connect = driver.connect(url, info);
    System.out.println(connect);

相较于方式一，这里仅仅使用反射实例化Driver，不在代码中体现第三方数据库的API。

连接方式三

// 方式三：使用DriverManager替换Driver
@Test
public void testConnection3() throws Exception 
    String url = "jdbc:mysql://localhost:3306/test";
    String user = "root";
    String password = "12345";
    Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
    Driver driver = (Driver) aClass.newInstance();
    // 注册驱动
    DriverManager.registerDriver(driver);
    Connection connection = DriverManager.getConnection(url, user, password);
    System.out.println(connection);

相较于方式二，这里不需要直接去访问实现了 Driver 接口的类（即通过Driver获取连接)，而是在驱动程序管理器类(java.sql.DriverManager)中注册驱动Driver，然后去调用这些Driver实现（即通过DriverManager获取数据库连接)。

连接方式四

// 方式四：可以只是加载驱动，不用显示的注册驱动。
@Test
public void testConnection4() throws Exception 
    String url = "jdbc:mysql://localhost:3306/test";
    String user = "root";
    String password = "12345";
    Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection(url, user, password);
    System.out.println(connection);

不必显式的创建Driver对象和注册驱动了。因为在Driver的源码中已经存在静态代码块(静态代码快回随着类的加载而加载)，实现了Driver对象的创建以及对驱动的注册。

连接方式五(最终版)

上面四种方式，都是把数据库相关信息硬编码在代码中，这样每当需要修改数据库信息，就需要修改代码。

例如在打包项目部署时，如果修改的源码，就需要重新打包项目，项目大的情况下，是很费时的

下面采用的方式五，是把代码和数据的分离，使用配置文件的方式保存数据，在代码中加载配置文件，好处如下

如果需要修改配置信息，直接在配置文件中修改，不需要深入代码
如果修改了配置信息，省去重新编译的过程（即重新打包)。

在工程的src目录下创建配置文件：【jdbc.properties】

user=root
password=abc123
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver

//方式五(final版)：将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
/*
* 此种方式的好处？
* 1.实现了数据与代码的分离。实现了解耦
* 2.如果需要修改配置文件信息，可以避免程序重新打包。
*/
@Test
public void testConnection5() throws Exception 
    //1.加载配置文件
    InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
    Properties properties = new Properties();
    properties.load(is);
    //2.读取配置信息
    String classDriver = properties.getProperty("driverClass");
    String url = properties.getProperty("url");
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    //3.加载驱动
    Class.forName(classDriver);
    //4.获取连接
    Connection connection = DriverManager.getConnection(url, user, password);
    System.out.println(connection);

相较于其他方式，方式五是通过系统类加载器的getResourceAsStream方法获取类路径下配置文件的输入流来加载配置文件信息的

2.3 URL

JDBC URL 用于标识一个被注册的驱动程序，通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。

JDBC URL的标准由三部分组成，各部分间用冒号分隔。

主协议：JDBC URL中的主协议总是jdbc
子协议：子协议用于标识一个数据库驱动程序
子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名

举例：

几种常用数据库的 JDBC URL

MySQL的连接URL编写方式：jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值

jdbc:mysql://localhost:3306/zhuo(连接到指定得数据库zhuo)
jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
jdbc:mysql://localhost:3306/atguigu?user=root&password=123456（连接数据库时指定用户和密码)

Oracle 9i的连接URL编写方式：jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称

jdbc:oracle:thin:@localhost:1521:zhuo

SQLServer的连接URL编写方式：jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称

jdbc:sqlserver://localhost:1433:DatabaseName=zhuo

三、PreparedStatement vs Statement

3.1 使用Statement操作数据表的弊端及缺点

通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。
Statement 接口中定义了下列方法用于执行 SQL 语句：

int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE
ResultSet executeQuery(String sql)：执行查询操作SELECT

使用Statement操作数据表的弊端：

问题一：存在拼串操作，繁琐
问题二：存在SQL注入问题

SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，例如在用户登录的sql检索语句中，可以利用拼串来绕过用户登录检查

用户的登录检索语句
使用拼串绕过检查

代码演示

public class StatementTest 

    // 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
    public static void main(String[] args) 
        Scanner scan = new Scanner(System.in);
        System.out.print("用户名：");
        String userName = scan.nextLine();
        System.out.print("密   码：");
        String password = scan.nextLine();
        String sql = "SELECT user,password FROM user_table WHERE USER = '1' or ' AND PASSWORD = '='1' or '1' = '1'";
        User user = get(sql, User.class);
        if (user != null) 
            System.out.println("登陆成功!");
         else 
            System.out.println("用户名或密码错误！");
        
    

    // 使用Statement实现对数据表的查询操作
    public static <T> T get(String sql, Class<T> clazz) 
        T t = null;
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try 
            // 1.加载配置文件
            InputStream is = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties pros = new Properties();
            pros.load(is);
            // 2.读取配置信息
            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            String url = pros.getProperty("url");
            String driverClass = pros.getProperty("driverClass");
            // 3.加载驱动
            Class.forName(driverClass);
            // 4.获取连接
            conn = DriverManager.getConnection(url, user, password);
            st = conn.createStatement();
            rs = st.executeQuery(sql);
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集的列数
            int columnCount = rsmd.getColumnCount();
            if (rs.next()) 
                t = clazz.newInstance();
                for (int i = 0; i < columnCount; i++) 
                    // 1. 获取列的别名
                    String columnName = rsmd.getColumnLabel(i + 1);
                    // 2. 根据列名获取对应数据表中的数据
                    Object columnVal = rs.getObject(columnName);
                    // 3. 将数据表中得到的数据，封装进对象
                    Field field = clazz.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                
                return t;
            
         catch (Exception e) 
            e.printStackTrace();
         finally 
            // 关闭资源
            if (rs != null) 
                try 
                    rs.close();
                 catch (SQLException e) 
                    e.printStackTrace();
                
            
            if (st != null) 
                try 
                    st.close();
                 catch (SQLException e) 
                    e.printStackTrace();
                
            
            if (conn != null) 
                try 
                    conn.close();
                 catch (SQLException e) 
                    e.printStackTrace();
                
            
        
        return null;

在Statement语句中，由于Statement是充当信使的，不能预编译，即每当有一条Statement语句,它便会送到数据库中执行，也就是说用户可以利用拼串来注入sql过滤条件来绕过检查。

使用Statement操作数据表的缺点：

不能操作Blog型数据

在Statement操作数据库中，Statement填充数据只能通过拼串，而BLOB类型的数据无法使用字符串拼接写的（blog数据需要填充IO流)

批量操作性能差

在Statement语句中，Statement是不能预编译的，即使是相同操作，但由于数据内容不一样,整个语句本身还是不能匹配,因此没有缓存语句的意义，批量操作性能差

事实上没有任何数据库会对普通语句编译后的执行代码缓存(即Statement送到数据库的sql语句)。这样每执行一次Statement语句(sql）都要对传入的语句编译一次。

3.2 PreparedStatement相比Statement的优点

PreparedStatement

可以通过调用 Connection 对象的 preparedStatement(String sql)方法获取 PreparedStatement 对象
PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

PreparedStatement 可以防止 SQL 注入

PreparedStatement语句是预编译语句，那为什么可以防止SQL注入呢？

因为PreparedStatement不再通过拼串的方式注入数据，而是通过占位符的方式来填充数据，这样当sql被预编译后，其sql语句就可以被确定下来，不管后面如何填充数据，最终的数据都会被认为是数据，而不是关键字（sql过滤条件等)

PreparedStatement可以实现更高效的批量操作

DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。

而批量操作执行的预编译语句是相同的，只是填充的数据不同，因此会被缓存下来，这样就可以实现更高效的批量操作

PreparedStatement可以操作Blog型数据

PreparedStatement是通过占位符来填充数据的，因此可以给单独的blog字段通过io流的方式写入数据

四、使用PreparedStatement实现CRUD操作

4.1 操作和访问数据库

数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。

在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：

Statement： 用于执行静态 SQL 语句并返回它所生成结果的对象（有sql注入风险，已被PrepatedStatement替代)。
PrepatedStatement： SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
CallableStatement： 用于执行 SQL 存储过程

4.2 使用PreparedStatement实现增、删、改操作(迭代)

由于增删改操作基本是一样的，所有下面采用insert语句来演示增删改查的迭代

版本一

@Test
 public void testInsert()  
     Connection connection = null;
     PreparedStatement preparedStatement = null;
     try 
         // 获取系统类加载器，调用系统类加载得器得getResourceAsStream方式加载类路径的文件获取输入流
         InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
         // 获取配置文件信息
         Properties properties = new Properties();
         properties.load(is);
         String driverClass = properties.getProperty("driverClass");
         String url = properties.getProperty("url");
         String user = properties.getProperty("user");
         String password = properties.getProperty("password");
         // 加载驱动
         Class.forName(driverClass);
         // 调用驱动管理器获取数据库连接
         connection = DriverManager.getConnection(url, user, password);
         String sql = "insert into customers(name,email,birth) value(?,?,?)";
         // 预编译sql
         preparedStatement = connection.prepareStatement(sql);
         // 填充占位符
         preparedStatement.setString(1, "迪丽热巴");
         preparedStatement.setString(2, "stormzhuo@163.com");
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
         Date date = simpleDateFormat.parse("1998-07-07");
         preparedStatement.setDate(3, new java.sql.Date(date.getTime()));
         // 执行sql语句
         preparedStatement以上是关于手撕JDBC笔记(含源码)，进阶框架必备的主要内容，如果未能解决你的问题，请参考以下文章 
 手撕JDBC笔记(含源码)，进阶框架必备
 手撕JDBC笔记，进阶框架必备
 手撕排序算法 - iOS进阶必备
 猿创征文｜前端进阶必备——WebSockt实现聊天室（附源码）
 猿创征文｜前端进阶必备——WebSockt实现聊天室（附源码）
 猿创征文｜前端进阶必备——WebSockt实现聊天室（附源码）