一文学会JDBC（两万字，适用于新手）

Posted 2021-11-22 爱你很久。

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了一文学会JDBC（两万字，适用于新手）相关的知识，希望对你有一定的参考价值。

10.PreparedStatement的使用

1.JDBC是什么？

Java数据库连接，（Java Database Connectivity，简称JDBC）是Java中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的

2.JDBC的本质是什么？

JDBC是sun公司置顶的一套接口(interface)

而这些接口都存在于java.sql.*包下

我们知道接口都有调用者和实现者，在JDBC中，很明显调用者是我们普通的Java程序员，那么谁是这些接口的实现者呢？

没错，就是各大数据库厂商，对于每一个数据库厂商，例如mysql，oracle，SqlServer等，都必须实现sun公司制定的这套接口，而我们程序员只需要根据自己使用的数据库，调用数据库厂商实现的接口方法即可。

思考：为什么sun公司制定一套JDBC接口呢？

因为每一个数据库的底层实现原理不一样

Oracle数据库有自己的原理

Mysql数据库也有自己的原理

SqlServer数据库也有自己的原理

...

每一个数据库产品都有自己独特的实现原理

原理图如下：

思考：为什么要面向接口编程？

面向接口调用、面向接口写实现类，这都属于面向接口编程

作用：

解耦合：降低程序的耦合度，提高程序的扩展力

多态机制就是非常典型的：面向抽象编程

//建议：
Animal a = new Cat();
Animal a = new Dog();

//不建议：
Dog d = new Dog();
Cat c = new Cat();

3.开发前的准备工作

JDBC开发前的准备工作，先从官网下载对应的驱动jar包

官网下载jar包的地址

MySQL :: Download Connector/J

这里我们开发分为两种情况

普通Java项目
Maven项目

如果我们创建的是普通的java项目，我们需要将jar包配置到项目中

而如果我们创建的是maven项目，直接在pom.xml文件中添加依赖即可

1.普通的Java项目添加jar包

上面我们下载下来的jar包文件，只需要用到下面这个标红的这个

然后我们在Intellij idea中创建一个普通的java项目JDBCTest

下面是导入jar包的过程：

第一步，创建一个lib文件，将jar包复制进去：

第二步，右键点击该jar包，选择 Add as Library...

第三步，选择Jar Directory

第四步，选择要将jar包导入哪个module，我们选择刚刚创建的JDBCTest

第五步，确定是否成功导入，打开Project Structure...(快捷键Ctrl + Alt + Shift + S)

第六步，点击Libraries，发现已经成功导入了

2.创建Maven项目添加依赖

如果创建的是Maven项目，我们直接在pom.xml文件中添加依赖

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
    </dependencies>

对于初学Java的人可能没有学过Maven，但我推荐没有学过Maven的人一定要去把Maven学了，Maven不难，但是对我们项目的帮助却特别大

4.JDBC编程六步（背会熟记）

第一步：注册驱动（告诉Java程序，即将连接的是哪个品牌的数据库）
第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道）
第三步：获取数据库操作对象（专门执行sql语句的对象）
第四步：执行sql语句（DQL DML...）
第五步：处理查询结果集（只有当第四步执行的select语句的时候，才由第五步处理查询结果集）
第六步：释放资源（使用完资源之后一定要关闭资源，Java和数据库属于进程间的通信，开启之后一定要关闭）

5. 具体实现

1.注册驱动

我们首先查看jdk帮助文档，发现有两个方法可以注册驱动

我们查看方法具体的解释，发现这个方法会抛出一个SQLException的异常，我们可以用try..catch来捕获异常。

其实我们编写JDBC注册驱动最常用的方法不是registerDriver()方法，最常用的方法是通过反射的类加载过程来注册驱动，这个后面我们会再详细讲解，我们这里首先采用registerDriver的方法来注册驱动

编写代码：

import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCTest01 {
    public static void main(String[] args) throws SQLException {
        try {
            //1.注册驱动
            Driver driver = new com.mysql.cj.jdbc.Driver();//父类型引用指向子类型对象
            DriverManager.registerDriver(driver);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        //2.获取连接
        //3.获取数据库操作对象
        //4.执行sql
        //5.处理查询结果
        //6.关闭连接
    }
}

可以看到这里是 new com.mysql.cj.jdbc.Driver()，那么com.mysql.cj.jdbc.Driver()和com.mysql.jdbc.Driver()有什么区别呢？

简单来说，如果使用的是Mysql6.0之后的版本，必须使用com.mysql.cj.jdbc.Driver()，而如果使用的是Mysql5.0的版本，使用的就是com.mysql.jdbc.Driver()

2.获取连接

我们查看jdk帮助文档，其中有三个方法可以获取连接

我们最常用的是第三个，查看第三个的详细解释

可以看到是返回的是一个Connection对象,这个就是获取到的连接对象，里面需要传三个参数，分别为url,user,password

url就是数据库连接地址
user就是数据库账号
password就是数据库密码

我们来解释一下url

url:统一资源定位符(网络中某个资源的绝对路径)

url包括哪几个部分？

协议
IP
PORT
资源名

举例：

http://220.181.38.251:80/index.html
http://                 通信协议
220.181.38.251         服务器IP地址
80                  服务器上软件的端口
index.html 服务器上某个资源名

jdbc:mysql://127.0.0.1:3306/demodatabase2
jdbc:mysql:// 协议
127.0.0.1 IP地址
3306 mysql数据库的端口号
demodatabase2 具体的数据库实例名

说明：localhost和127.0.0.1都是本机IP地址

编写程序：

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCTest01 {
    public static void main(String[] args) throws SQLException {
        try {
            //1.注册驱动
            Driver driver = new com.mysql.cj.jdbc.Driver();//父类型引用指向子类型对象
            DriverManager.registerDriver(driver);

            //2.获取连接
            /*
            url:统一资源定位符(网络中某个资源的绝对路径)
            URL包括哪几个部分？
                协议
                IP
                PORT
                资源名
            http://220.181.38.251:80/index.html
                http://         通信协议
                220.181.38.251  服务器IP地址
                80              服务器上软件的端口
                index.html      服务器上某个资源名

            jdbc:mysql://127.0.0.1:3306/demodatabase2
            jdbc:mysql://   协议
            127.0.0.1       IP地址
            3306            mysql数据库的端口号
            demodatabase2   具体的数据库实例名

            说明：localhost和127.0.0.1都是本机IP地址

            什么是通信协议，有什么用？
                通信协议是通信之前就提前定好的数据传送格式
                数据包具体怎么传数据，格式提前定好的
            */
            String url = "jdbc:mysql://127.0.0.1:3306/demodatabase2";
            String user = "root";
            String password = "root";
            Connection connection = DriverManager.getConnection(url, user, password);
            System.out.println("数据库连接对象：" + connection);
        } catch (SQLException e) {
            e.printStackTrace();
        }


        //3.获取数据库操作对象
        //4.执行sql
        //5.处理查询结果
        //6.关闭连接
    }
}

运行以下，控制台输出：

如果上面的代码连接失败，试着将url改成下面这个，这个设置了时区

String url = "jdbc:mysql://localhost:3306/demodatabase2?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";

3.获取数据库操作对象

查看jdk帮助文档

发现有三个方法，常用的是第一个方法，我们查看具体的解释

可以发现这个方法返回一个Statement对象，用于将sql语句发送到数据库

编写代码：

import java.sql.*;

public class JDBCTest01 {
    public static void main(String[] args) throws SQLException {
        try {
            //1.注册驱动
            Driver driver = new com.mysql.cj.jdbc.Driver();//父类型引用指向子类型对象
            DriverManager.registerDriver(driver);

            //2.获取连接
            String url = "jdbc:mysql://127.0.0.1:3306/demodatabase2";
            String user = "root";
            String password = "root";
            Connection connection = DriverManager.getConnection(url, user, password);

            //3.获取数据库操作对象
            Statement stmt = connection.createStatement();
            
        } catch (SQLException e) {
            e.printStackTrace();
        }



        //4.执行sql
        //5.处理查询结果
        //6.关闭连接
    }
}

4.执行sql，关闭连接

我们查看jdk帮助文档

首先我们执行一次INSERT插入操作，我们可以看到用红色标注起来的这个方法，点进去查看具体的解释

该方法执行给定的SQL语句，可以执行INSERT,UPDATE,DELETE，但是不能执行SELECT，返回的是一个int类型，表示影响数据库中的记录条数

这里我们用insert来对数据库demodatabase2中student表进行插入操作

数据库中的student表是这样设计的

编写代码：

import java.sql.*;

public class JDBCTest01 {
    public static void main(String[] args) throws SQLException {
        Statement stmt = null;
        Connection connection = null;
        try {
            //1.注册驱动
            Driver driver = new com.mysql.cj.jdbc.Driver();//父类型引用指向子类型对象
            DriverManager.registerDriver(driver);

            //2.获取连接
            String url = "jdbc:mysql://127.0.0.1:3306/demodatabase2";
            String user = "root";
            String password = "root";
            connection = DriverManager.getConnection(url, user, password);

            //3.获取数据库操作对象
            stmt = connection.createStatement();

            //4.执行sql
            String sql = "INSERT INTO student(id,age,name) VALUES(16,65,\\"魏桑\\")";
            //专门指定DML语句的(insert delete update)
            //返回值是"影响数据库中的记录条数"
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "保存成功" : "保存失败");

            //5.处理查询结果集(只有select语句才会使用到)
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //6.关闭连接
            //为了保证资源一定释放，在finally语句块中关闭资源
            //并且要遵循从小到大依次关闭
            //分别对其try...catch
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            
        }
    }
}

控制台输出：

我们查看student表，发现第16条数据已经插入了。

6. JDBC执行删除与更新

1.删除操作

仿照第五步的操作步骤，我们来删除student表中上一步添加的id为16号的数据

编写代码

import com.mysql.cj.jdbc.Driver;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCTest02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //1.注册驱动
            Driver driver = new Driver();
            DriverManager.registerDriver(driver);
            //2.获取连接
            String url = "jdbc:mysql://localhost:3306/demodatabase2";
            String user = "root";
            String password = "root";
            conn = DriverManager.getConnection(url,user,password);

            //3.获取数据库操作对象
            stmt = conn.createStatement();

            //4.执行sql语句
            String sql = "DELETE FROM student WHERE id = 16";
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "删除成功" : "删除失败");

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //6.释放资源
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

控制台输出：

查看student的表，id为16的数据已经被删除了。

2.更新操作

我们直接在上一步的基础上来更改代码，将id为15的名字改为魏桑

编写代码：

import com.mysql.cj.jdbc.Driver;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCTest03 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //1.注册驱动
            Driver driver = new Driver();
            DriverManager.registerDriver(driver);
            //2.获取连接
            String url = "jdbc:mysql://localhost:3306/demodatabase2";
            String user = "root";
            String password = "root";
            conn = DriverManager.getConnection(url,user,password);

            //3.获取数据库操作对象
            stmt = conn.createStatement();

            //4.执行sql语句
            String sql = "UPDATE student SET name = \\"魏桑\\" WHERE id = 15";
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "更新成功" : "更新失败");

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //6.释放资源
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

控制台输出：

我们查看student表，可以看到id为15的数据更新成功了

7.类加载的方式注册驱动

我们查看mysql公司实现的Driver接口

而DriverManager.registerDriver(new Driver())在静态代码块中

如果我们要想将类的静态代码块加载，只需要加载这个类即可，那么显而易见我们可以通过反射来实现。

关于反射的知识可以查看我这篇文章，写的很清晰

java基础之反射详解_ypxcan的博客-CSDN博客_java基础之反射

编写代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCTest04 {
    public static void main(String[] args) {

        try {
            //1.注册驱动
            //这是注册驱动的第一种写法
            //DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
            //这是第二种方式，也最常规的写法，通过类加载机制
            //为什么这种方式最常用? 因为参数时一个字符串，字符串可以写到xxx.properties文件中
            //以下方法不需要接收返回值，因为我们只想用它的类加载动作
            Class.forName("com.mysql.cj.jdbc.Driver");

            //2.获取连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/demodatabase2", "root", "root");
            System.out.println(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

8.从属性资源文件中读取连接数据库信息

我们创建jdbc.properties文件，里面填入driver,url,user,password

重新编写代码

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JDBCTest05 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        Properties properties = new Properties();
        FileReader fr = null;
        try {
            fr = new FileReader("java-15-JDBC\\\\src\\\\main\\\\java\\\\jdbc.properties");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            properties.load(fr);
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println(properties.getProperty("driver"));

        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");

        try {
            //1.注册驱动

            Class.forName(driver);

            //2.获取连接
            conn = DriverManager.getConnection(url,user,password);

            //3.获取操作对象
            stmt = conn.createStatement();

            //4.执行sql
            String sql = "INSERT INTO student(id,age,name) VALUES(16,45,\\"周星驰\\")";
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "插入成功" : "插入失败");
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

或者我们使用资源绑定器来优化代码

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.ResourceBundle;

public class JDBCTest06 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");

        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");

        try {
            //1.注册驱动

            Class.forName(driver);

            //2.获取连接
            conn = DriverManager.getConnection(url,user,password);

            //3.获取操作对象
            stmt = conn.createStatement();

            //4.执行sql
            String sql = "INSERT INTO student(id,age,name) VALUES(17,45,\\"周星驰\\")";
            int count = stmt.executeUpdate(sql);
            System.out.println(count == 1 ? "插入成功" : "插入失败");
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

9.处理查询结果集

我们查看jdk帮助文档，发现如果想要执行SELECT语句，使用的是executequery方法，该返回一个ResultSet结果集对象

我们查看详细的解释

我们再去查看ResultSet类，里面有一个next方法，明确清楚着写着ResultSet光标最初位于第一行之前，所以我们只有调用一次next方法后，光标才会处于结果集的第一行。

我们来完善代码：

package com.lu.jdbc;

import java.sql.*;
import java.util.ResourceBundle;

public class JDBCTest07 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String user = bundle.getString("user");
        String url = bundle.getString("url");
        String password = bundle.getString("password");

        try {
            //1.注册驱动
            Class.forName(driver);

            //2.获取连接
            conn = DriverManager.getConnection(url,user,password);

            //3.获取数据库操作对象
            stmt = conn.createStatement();

            //4.执行sql语句
            String sql = "SELECT * FROM student";
            rs = stmt.executeQuery(sql);//专门执行DQL的方法

            //5.处理查询结果集
            while (rs.next()) {
                String id = rs.getString("id");
                String age = rs.getString("age");
                String name = rs.getString("name");
                System.out.print("id: " + id);
                System.out.print(" age: " + age);
                System.out.println(" name: " + name);
            }


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

控制台输出：

10.PreparedStatement的使用

解决sql注入问题，属于预编译的数据库操作对象

PreparedStatement的原理是：预先对SQL语句的框架进行编译，然后再给sql语句传“值”

前面我们所讲的获取数据库操作对象是通过createStatement()方法，但是对于大部分来讲，createStatement方法是有漏洞的，他无法解决sql注入问题，关于PreparedStatement如何解决sql注入问题，可以查看下面这篇文章

PreparedStatement是如何防止SQL注入的？ - 栖息之鹰 - 博客园

我们来编写代码

package com.lu.jdbc;

import java.sql.*;
import java.util.ResourceBundle;

public class JDBCTest08 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String user = bundle.getString("user");
        String url = bundle.getString("url");
        String password = bundle.getString("password");

        try {
            //1.注册驱动
            Class.forName(driver);

            //2.获取连接
            conn = DriverManager.getConnection(url,user,password);

            //3.获取数据库操作对象
            String sql = "SELECT * FROM student WHERE id = ?";
            ps = conn.prepareStatement(sql);
            //给占位符?传值(第一个问号下标是1，第二个问号下标是2，JDBC中所有下标从1开始)
            ps.setInt(1,15);

            //4.执行sql语句
            rs = ps.executeQuery();

            //5.处理查询结果集
            while (rs.next()) {
                String id = rs.getString("id");//JDBC中所有下标都是从1开始，不是从0开始
                String age = rs.getString("age");
                String name = rs.getString("name");
                System.out.print("id: " + id);
                System.out.print(" age: " + age);
                System.out.println(" name: " + name);
            }


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Statement和PreparedStatement的区别

1.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程

2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。

3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得, preparedstatement支持批处理

结论：

PreparedStatement使用较多，只有极少数的情况下需要使用Statement

这篇文章只是讲解了如何使用JDBC，而关于更深层次的问题，比如Statement是如何产生sql注入问题的，为什么我们选择使用PreparedStatement而不是Statement,Statement不能解决sql注入问题为什么还存在着，Statement的应用场景是什么，悲观锁和乐观锁等问题我们都没有讲解到，但这篇文章对于新手来说，足够可以使用Java对Mysql进行上手，希望这篇文章可以帮助更多的Java新手，如果有什么问题可以在评论区指出，谢谢你的观看！

以上是关于一文学会JDBC（两万字，适用于新手）的主要内容，如果未能解决你的问题，请参考以下文章

一文学完所有的Hive Sql（两万字最全详解）

这些Java常用类，你必须要学会，还不快快收藏？（近两万字详细介绍）

两万字Mybatis源码剖析

一文学会Perl语言

JAVA高级——一文学会JDBC操作数据库

糊涂算法之「八大排序」总结——用两万字，8张动图，450行代码跨过排序这道坎（建议收藏）