JDBC应用介绍-CSDN博客

本文链接：https://blog.csdn.net/weixin_42844241/article/details/133058393

第一章：JDBC

引入

客户端操作 MySQL 数据库的方式：

1、使用第三方客户端来访问 MySQL：

SQLyog、Navicat、SQLWave、MyDB Studio、EMS SQL Manager for MySQL

2、使用MySQL自带的命令格式

3、通过Java来访问MySQL数据库

什么是 JDBC？

　　JDBC 规范定义接口，具体的实现由各大数据库厂商来实现。

　　JDBC 是 Java 访问数据库的标准规范，真正怎么操作数据库还需要具体的实现类，也就是数据库驱动。每个数据库厂商根据自家数据库的通信格式编写好自己数据库的驱动。所以我们只需要会调用 JDBC 接口中的方法即可，数据库驱动由数据库厂商提供。

使用JDBC的好处：

会使用接口方法，不需关注如何实现

程序员开发数据库程序，只需要会调用JDBC接口中的方法，不用关注类是怎么实现的。

少量修改、高效率、应用范围广

使用同一套 Java 代码，进行少量的修改就可以访问其他 JDBC 支持的数据库

使用 JDBC 开发使用到的包：

JDBC 的核心 API：

导入驱动 Jar 包

加载和注册驱动：

package com.lqg;
public class Demo1 {
    public static void main(String[] args) throws             
             ClassNotFoundException {
             //抛出类找不到的异常，注册数据库驱动
             Class.forName("com.mysql.jdbc.Driver");
          }
    }
 
com.mysql.jdbc.Driver 源代码：

// Driver 接口，所有数据库厂商必须实现的接口，表示这是一个驱动类。
public class Driver implements java.sql.Driver {

    public Driver() throws SQLException {

    }

    static {
         try {
              DriverManager.registerDriver(new Driver()); //注册数据库驱动
              } catch (SQLException var1) {
         throw new RuntimeException("Can't register driver!");
        }
    }
}

注意：JDBC3开始，到目前使用版本。可以不用注册驱动而直接使用。Class.forName可以省略

第二章：DriverManager类

DriverManager 作用：

管理和注册驱动

创建数据库的连接

类中的方法：

静态方法：

　　Connection getConnection (String url, String user, String password)

　　通过连接字符串，用户名，密码来得到数据库的连接对象

　　Connection getConnection (String url, Properties info)

　　通过连接字符串，属性对象来得到连接对象

使用 JDBC 连接数据库的四个参数：

用户名	登录的用户名
密码	登录的密码
连接字符串 URL	不同的数据库 URL 是不同的，mysql 的写法 jdbc:mysql://localhost:3306/数据库[?参数名=参数值]
驱动类的字符串名	com.mysql.jdbc.Driver

连接数据库的 URL 地址格式：

协议名:子协议://服务器名或 IP 地址:端口号/数据库名?参数=参数值

写法：

MySQL中可以简写：

前提：必须是本地服务器，端口号是 3306

　　　　jdbc:mysql:///数据库名

注意：　　

　　如果数据库出现乱码，可以指定参数: ?characterEncoding=utf8，表示让数据库以 UTF-8 编码来处理数据。

jdbc:mysql://localhost:3306/数据库?characterEncoding=utf8

案例：得到 MySQL 的数据库连接对象

使用用户名、密码、URL 得到连接对象

import java.sql.Connection;
import java.sql.DriverManager;

public class Demo {
    public static void main(String[] args) throws Exception {
        // 加载和注册数据路驱动
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/demotest";
        Connection connection = DriverManager.getConnection(url, "root", "1234");
        System.out.println(connection);
    }
}

使用属性文件和 url 得到连接对象

package com.peihua.cn;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class Demo2 {
    public static void main(String[] args) throws SQLException {
        //url 连接字符串
        String url ="jdbc:mysql://localhost:3306/demotest";
        // 创建属性对象
        Properties info = new Properties();
        // 将用户名密码放入info对象中
        info.setProperty("user","root");
        info.setProperty("password","1234");
        // 创建数据库对象，通过DriverManager 类方法，将数据库位置和用户名密码给到数据库对象，连接
        Connection connection = DriverManager.getConnection(url,info);
        System.out.println(connection);
    }
}

第三章：Conection接口

Connection 作用：

　　具体的实现类由数据库的厂商实现，代表一个连接对象。

Connection 方法：

Statement createStatement()

创建一条 SQL 语句对象

第四章：Statement接口

JDBC 访问数据库的步骤：

(1) 注册和加载驱动(可以省略)

(2) 获取连接

(3) Connection 获取 Statement 对象

(4) 使用 Statement 对象执行 SQL 语句

(5) 返回结果集

(6) 释放资源

Statement 作用：

代表一条语句对象，用于发送 SQL 语句给服务器，用于执行静态 SQL 语句并返回它所生成结果的对象。

Statement 中的方法：

int executeUpdate(String sql)

用于发送 DML 语句，增删改的操作，insert、update delete

参数：SQL 语句

返回值：返回对数据库影响的行数

ResultSet executeQuery(String sql)

用于发送 DQL 语句，执行查询的操作。select

参数：SQL 语句

返回值：查询的结果集

释放资源

(1) 需要释放的对象：ResultSet 结果集，Statement 语句，Connection 连接

(2) 释放原则：先开的后关，后开的先关。ResultSet  Statement  Connection

(3) 放在哪个代码块中：finally 块

执行 DDL 操作

使用JDBC在MySQL中创建一张数据表

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

public class Demo3 {
    public static void main(String[] args) {
        // 注册和加载驱动，
        // 获取连接，
        // connection获取Ststement对象，
        // 使用statement对象执行sql语句，
        // 返回结果，
        // 释放资源
        // 创建链接
        Connection conn = null;
        Statement statement = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/demotest", "root", "1234");
            // 通过连接对象得到语句对象
            statement = conn.createStatement();
            // 通过语句对象发送SQL语句给服务器
            // 执行SQL语句
            statement.executeUpdate("create table student1(id int primary key auto_increment, " +
                    "name varchar (20) not null,gender boolean,birthday date)");
            // 返回影响行数(DDl没有返回值)结果
            System.out.println("创建表成功");

        } catch (SQLException e) {
            e.printStackTrace();
            // 释放资源，finally必须执行，
        } finally {
            //判断是否是空即还有没有语句
            if (statement != null) {
                // 抛出异常
                try {
                    // 关闭资源，再程序运行过程中，会申请到一部分资源，当程序运行结束，系统要回收资源
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                if (conn != null) {
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }
}

执行 DML 操作

表添加记录

步骤：

(1) 创建连接对象

(2) 创建 Statement 语句对象

(3) 执行 SQL 语句：executeUpdate(sql)

(4) 返回影响的行数

(5) 释放资源

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

public class Demo4 {
    public static void main(String[] args) throws SQLException {
        // 创建连接对象
        Connection connection = DriverManager.getConnection("jdbc:mysql:///demotest", "root", "1234");
        // 创建Statement语句对象
        Statement statement = connection.createStatement();
        // 定义变量用于计数
        int count = 0;
        // 返回影响行数
        count += statement.executeUpdate("insert  into student values (null ,'孙悟空',1,'1993-03-24')");
        count += statement.executeUpdate("insert  into student values (null ,'拜拜拜',0,'1993-03-24')");
        count += statement.executeUpdate("insert  into student values (null ,'程序洒',1,'1993-03-24')");
        count += statement.executeUpdate("insert  into student values (null ,'测试空',1,'1993-03-24')");
        count += statement.executeUpdate("insert  into student values (null ,'的地方',1,'1993-03-24')");
        System.out.println("插入了" + count + " 条记录");
        // 关闭资源，先进后关，后进先关
        statement.close();
        connection.close();
    }
}

执行 DQL 操作

了解和应用ResultSet 接口：

作用：封装数据库查询的结果集，对结果集进行遍历，取出每一条记录。

接口中的方法：

boolean next()

　　(1) 游标向下移动 1 行

　　(2) 返回 boolean 类型，如果还有下一条记录，返回 true，否则返回 false

数据类型 getXxx()

　　(1) 通过字段名，参数是 String 类型。返回不同的类型

　　(2) 通过列号，参数是整数，从 1 开始。返回不同的类型

常用数据类型转换表：

java.sql.Date、Time、Timestamp(时间戳)，三个共同父类是：java.util.Date

需求：查询所有的学员信息

步骤：

(1) 得到连接对象

(2) 得到语句对象

(3) 执行 SQL 语句得到结果集 ResultSet 对象

(4) 循环遍历取出每一条记录

(5) 输出的控制台上

(6) 释放资源

package com.peihua.cn;

import java.sql.*;

public class Demo5 {
    public static void main(String[] args) throws SQLException {
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/demotest","root","1234"); Statement statement =connection.createStatement(); ResultSet resultSet = statement.executeQuery("select * from student"); while (resultSet.next()){ int id = resultSet.getInt("id"); String name = resultSet.getString("name"); boolean gender = resultSet.getBoolean("gender"); Date birthday = resultSet.getDate("birthday"); System.out.println("编号"+id+", 姓名"+name +",性别"+gender+",生日"+birthday); } resultSet.close(); statement.close(); connection.close(); } }

注意事项：

如果光标在第一行之前，使用 rs.getXX()获取列值，报错：Before start of result set
如果光标在最后一行之后，使用 rs.getXX()获取列值，报错：After end of result set
使用完毕以后要关闭结果集 ResultSet，再关闭 Statement，再关闭 Connection

第五章：数据库工具类JdbcUtils

什么时候自己创建工具类？

　　如果一个功能经常要用到，我们建议把这个功能做成一个工具类，可以在不同的地方重用。

示例：

需求：

1) 有一张用户表

2) 添加几条用户记录

create table user (
    id int primary key auto_increment,
    name varchar(20),
    password varchar(20)
)

insert into user values (null,'jack','123'),(null,'rose','456');

-- 登录, SQL 中大小写不敏感
select * from user where name='JACK' and password='123';

-- 登录失败
select * from user where name='JACK' and password='333';

3) 使用 Statement 字符串拼接的方式实现用户的登录, 用户在控制台上输入用户名和密码。

步骤：

1) 得到用户从控制台上输入的用户名和密码来查询数据库

2) 写一个登录的方法

a) 通过工具类得到连接

b) 创建语句对象，使用拼接字符串的方式生成 SQL 语句

c) 查询数据库，如果有记录则表示登录成功，否则登录失

d) 释放资源

import java.sql.*;

public class JdbcUtils {
    //可以把几个字符串定义成常量：用户名，密码，URL，驱动类
    private static final String USER = "root";
    private static final String PWD = "1234";
    private static final String URL = "jdbc:mysql://localhost:3306/demotest";
    private static final String DRIVER = "com.mysql.jdbc.Driver";

    /**
     * 注册驱动
     */
    static {
        try {
            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 得到数据库的连接
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PWD);
    }

    /**
     * 关闭所有打开的资源
     */
    public static void close(Connection conn, Statement stmt) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭所有打开的资源
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        close(conn, stmt);
    }
}

SQL 注入问题

当我们输入以下密码，我们发现我们账号和密码都不对竟然登录成功了

请输入用户名：
newboy
请输入密码：
a' or '1'='1
select * from user where name='newboy' and password='a' or '1'='1'
登录成功，欢迎您：newboy

问题分析：

select * from user where name='newboy' and password='a' or '1'='1'
name='newboy' and password='a' 为假
'1'='1' 真
相当于
select * from user where true; 查询了所有记录

　　我们让用户输入的密码和 SQL 语句进行字符串拼接。用户输入的内容作为了 SQL 语句语法的一部分，改变了原有 SQL 真正的意义，以上问题称为 SQL 注入。要解决 SQL 注入就不能让用户输入的密码和我们的 SQL 语句进行简单的字符串拼接。

第六章：PreparedStatement

继承结构与作用：

　　PreparedStatement 是 Statement 接口的子接口，继承于父接口中所有的方法。它是一个预编译的 SQL 语句

PreparedSatement 的执行原理

因为有预先编译的功能，提高 SQL 的执行效率。

可以有效的防止 SQL 注入的问题，安全性更高。

Connection 创建 PreparedStatement 对象

PreparedStatement prepareStatement(String sql)

指定预编译的 SQL 语句，SQL 语句中使用占位符?

创建一个语句对象

PreparedStatement 接口中的方法：

int executeUpdate()	执行 DML，增删改的操作，返回影响的行数。
ResultSet executeQuery()	执行 DQL，查询的操作，返回结果集

PreparedSatement 的好处

1. prepareStatement()会先将 SQL 语句发送给数据库预编译。PreparedStatement 会引用着预编译后的结果。

可以多次传入不同的参数给 PreparedStatement 对象并执行。减少 SQL 编译次数，提高效率。

2. 安全性更高，没有 SQL 注入的隐患。

3. 提高了程序的可读性

使用 PreparedStatement 的步骤：

1) 编写 SQL 语句，未知内容使用?占位："SELECT * FROM user WHERE name=? AND password=?";

2) 获得 PreparedStatement 对象

3) 设置实际参数：setXxx(占位符的位置, 真实的值)

4) 执行参数化 SQL 语句

5) 关闭资源

void setDouble(int parameterIndex, double x)

　　将指定参数设置为给定 Java double 值。void setFloat(int parameterIndex, float x)

　　将指定参数设置为给定 Java REAL 值。void setInt(int parameterIndex, int x)

　　将指定参数设置为给定 Java int 值。void setLong(int parameterIndex, long x)

　　将指定参数设置为给定 Java long 值。void setObject(int parameterIndex, Object x)

　　使用给定对象设置指定参数的值。void setString(int parameterIndex, String x)

　　将指定参数设置为给定 Java String 值。

表与类的关系

package com.lqg;
import com.itheima.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Scanner;
/**
* 使用 PreparedStatement
*/
public class Demo8Login {
    //从控制台上输入的用户名和密码
    public static void main(String[] args) throws SQLException {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入用户名");
    String name = sc.nextLine();
    System.out.println("请输入密码：");
    String password = sc.nextLine();
    login(name, password);
}
/**
* 登录的方法
* @param name
16 / 21
* @param password
*/
private static void login(String name, String password) throws SQLException {
    Connection connection = JdbcUtils.getConnection();
    //写成登录 SQL 语句，没有单引号
    String sql = "select * from user where name=? and password=?";
    //得到语句对象
    PreparedStatement ps = connection.prepareStatement(sql);
    //设置参数
    ps.setString(1, name);
    ps.setString(2,password);
    ResultSet resultSet = ps.executeQuery();
    if (resultSet.next()) {
    System.out.println("登录成功：" + name);
    }
    else {
    System.out.println("登录失败");
    }
    //释放资源,子接口直接给父接口
    JdbcUtils.close(connection,ps,resultSet);
    } 
}

案例一：使用 PreparedStatement 查询一条数据，封装成一个学生 Student 对象

package com.peihua.cn;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Demo8 {
    public static void main(String[] args) throws SQLException {
        Student student =new Student();
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement("select *from student where id=?");
        preparedStatement.setInt(1,2);
        ResultSet resultSet = preparedStatement.executeQuery();
        if (resultSet.next()){
            student.setId(resultSet.getInt("id"));
            student.setName(resultSet.getString("name"));
            student.setGender(resultSet.getBoolean("gender"));
            student.setBirthday(resultSet.getDate("birthday"));
        }
        JdbcUtils.close(connection,preparedStatement,resultSet);
        System.out.println(student);
    }
}

案例二：将多条记录封装成集合 List<Student>，集合中每个元素是一个 JavaBean 实体类

需求：查询所有的学生类，封装成 List<Student>返回

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Demo9 {
    public static void main(String[] args) throws SQLException {
        List<Student> students = new ArrayList<Student>();
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement("select * from student");
        ResultSet resultSet = preparedStatement.executeQuery();
        while (resultSet.next()){
            Student student = new Student();
            student.setId(resultSet.getInt("id"));
            student.setName(resultSet.getString("name"));
            student.setGender(resultSet.getBoolean("gender"));
            student.setBirthday(resultSet.getDate("birthday"));
            students.add(student);
        }
        JdbcUtils.close(connection,preparedStatement,resultSet);
        for (Student student1:students){
            System.out.println(student1);
        }

    }
}

PreparedStatement 执行 DML 操作

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.CopyOnWriteArrayList;

public class Demo10 {
    public static void main(String[] args) throws SQLException {
        insert();
        delete();
        update();
    }

    private static void update() throws SQLException {
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement("update student set name =?,birthday=? where id=?");
        preparedStatement.setString(1, "黑熊怪");
        preparedStatement.setDate(2, java.sql.Date.valueOf("1999-03-23"));
        preparedStatement.setInt(3, 5);
        int row = preparedStatement.executeUpdate();
        System.out.println("更新" + row + "条记录");
        JdbcUtils.close(connection, preparedStatement);
    }

    private static void insert() throws SQLException {
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement("insert  into  student values (null ,?,?,?)");
        preparedStatement.setString(1, "xcc");
        preparedStatement.setBoolean(2, true);
        preparedStatement.setDate(3, java.sql.Date.valueOf("1998-11-11"));
        int row = preparedStatement.executeUpdate();
        System.out.println("插入" + row + "条数据");
        JdbcUtils.close(connection, preparedStatement);
    }

    private static void delete() throws SQLException {
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement("delete from student where  id=?");
        preparedStatement.setInt(1, 5);
        int row = preparedStatement.executeUpdate();
        System.out.println("删除" + row + "记录");
        JdbcUtils.close(connection, preparedStatement);
    }
}

第七章：JDBC的事务处理

准备数据

CREATE TABLE account (
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(10),
balance DOUBLE
);
-- 添加数据
INSERT INTO account (NAME, balance) VALUES ('Jack', 1000), ('Rose', 1000);

API 介绍

void setAutoCommit(boolean autoCommit)	参数是 true 或 false
	如果设置为 false，表示关闭自动提交，相当于开启事务
void commit()	提交事务
void rollback()	回滚事务

开发步骤

1) 获取连接

2) 开启事务

3) 获取到 PreparedStatement

4) 使用 PreparedStatement 执行两次更新操作

5) 正常情况下提交事务

6) 出现异常回滚事务

7) 最后关闭资源

package com.peihua.cn;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class DemoTransaction {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JdbcUtils.getConnection();
            connection.setAutoCommit(false);
            preparedStatement = connection.prepareStatement("update account set  balance = balance - ? where  name = ?");
            preparedStatement.setInt(1, 500);
            preparedStatement.setString(2, "Jack");
            preparedStatement.executeUpdate();
            System.out.println(100 / 0);
            preparedStatement = connection.prepareStatement("update account set  balance = balance + ? where  name = ?");
            preparedStatement.setInt(1, 500);
            preparedStatement.setString(2, "Rose");
            preparedStatement.executeUpdate();
            connection.commit();
            System.out.println("转账成功");
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            System.out.println("转账失败");
        } finally {
            JdbcUtils.close(connection, preparedStatement);
        }
    }
}