十、JDBC（重点）
1. 数据库驱动
- 应用程序通过驱动，连接数据库，如：MySQL 驱动、Oracle 驱动；
image
2. JDBC 介绍
JDBC ：Java Data Base Connectivity（Java 数据库连接），是 Java 操作数据库的统一规范，主要由接口组成；
组成 JDBC 的２个包：java.sql、javax.sql；
开发 JDBC 应用需要以上 2 个包的支持外，还需要导入相应 JDBC 的数据库实现（即数据库驱动）；
-
image
3. 编写 JDBC 程序
- 创建测试数据库
CREATE DATABASE `jdbcStudy` CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
USE `jdbcStudy`;
CREATE TABLE `users` (
`id` INT NOT NULL,
`name` VARCHAR(40) DEFAULT NULL,
`password` VARCHAR(40) DEFAULT NULL,
`email` VARCHAR(60) DEFAULT NULL,
`birthday` DATE DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;
INSERT INTO `users`(`id`,`name`,`password`,`email`,`birthday`)
VALUES(1,'zhansan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04');
- 新建 Java 工程，并导入数据驱动
image
- 连接测试：
package com.xxx.demo01;
import java.sql.*;
public class JdbcFirstDemo {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
// 要连接的数据库 URL
/*
1.jdbc:mysql://主机地址:端口号/数据库名?参数1&参数2&...;
2.?：连接参数 &：参数分隔符
2.useUnicode=true：使用Unicode字符集，支持中文编码
3.characterEncoding=utf8：编码
4.useSSL=true：使用安全的链接
5.serverTimezone=UTC：设置时区
*/
String url = "jdbc:mysql://localhost:3306/jdbcStudy?" +
"useUnicode=true&characterEncoding=utf8& useSSL=true";
// 连接的数据库时使用的用户名
String username = "root";
// 连接的数据库时使用的密码
String password = "123456";
// 1.加载驱动（通过反射）
// mysql8驱动
Class.forName("com.mysql.cj.jdbc.Driver");
// mysql5.7驱动
// Class.forName("com.mysql.jdbc.Driver");
// 不推荐使用这种方式来加载驱动
// DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
// 2.连接数据库
Connection conn = DriverManager.getConnection(url, username, password);
// 3.获取用于向数据库发送sql语句的执行对象Statement
Statement st = conn.createStatement();
// 4.向数据库发sql,并获取代表结果集的resultset
String sql = ("SELECT * FROM `users`;");
// 5.执行sql
ResultSet rs = st.executeQuery(sql);
// 6.取出结果集的数据
while (rs.next()) {
System.out.println("id=" + rs.getObject("id"));
System.out.println("name=" + rs.getObject("name"));
System.out.println("password=" + rs.getObject("password"));
System.out.println("email=" + rs.getObject("email"));
System.out.println("birthday=" + rs.getObject("birthday"));
System.out.println("=====================");
}
// 7.关闭链接，释放资源（从后向前）
rs.close();
st.close();
conn.close();
}
}
image
连接数据库七大步骤：
- 加载驱动；
- MySQL8：
com.mysql.cj.jdbc.Driver； - MySQL5.7：
com.mysql.jdbc.Driver。
- MySQL8：
- 连接数据库 DriverManager（驱动管理）；
- 获取 sql 的执行对象 Statement；
- 写 sql；
- 执行 sql；
- 获得返回的结果集；
- 释放连接。
4. 对象说明
DriverManager 类：加载驱动
- Jdbc 程序中的 DriverManager 用于加载驱动，并创建与数据库的链接，这个 API 的常用方法：
DriverManager.registerDriver(new Driver());
DriverManager.getConnection(url, user, password);
- 注意：实际开发中，不推荐 registerDriver 方法注册驱动：
- 通过 Driver 的源代码看到，此种方式，驱动程序会注册两次，内存中会有两个 Driver 对象；
- 程序依赖 mysql 的 API，脱离 mysql 的 jar 包，程序将无法编译，以后程序切换底层数据库，会非常麻烦。
- 推荐方式：
Class.forName("com.mysql.cj.jdbc.Driver"); - 此方式不会导致驱动对象，在内存中重复出现，并且程序只需要一个字符串， 不需要依赖具体的驱动，使程序的灵活性更高。
数据库 URL
- URL 用于标识数据库的位置，通过 URL 地址告诉 JDBC 程序连接哪个数据库，写法为：
image
- 常用数据库 URL 地址的写法：
- Oracle 写法：
jdbc:oracle:thin:@localhost:1521:sid; - SqlServer 写法：
jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=sid; - MySQL 写法：
jdbc:mysql://localhost:3306/sid;
- Oracle 写法：
Connection 类（重要）：代表数据库
- Connection：用于代表数据库的链接，是数据库编程中，最重要的一个对象，客户端与数据库所有交互，都是通过 connection 对象完成的；
- 常用方法：
-
createStatement()：创建向数据库发送 sql 的 statement 对象； -
prepareStatement(sql)：创建向数据库发送预编译 sql 的PrepareSatement 对象； -
setAutoCommit(boolean autoCommit)：设置事务是否自动提交； -
commit()：在链接上提交事务； -
rollback()：在此链接上回滚事务。
-
Statement 类：执行 sql 对象
- 用于向数据库发送 SQL 语句，常用方法：
-
executeQuery(String sql)：查询语句； -
executeUpdate(String sql)：insert、update或delete语句； -
execute(String sql)：任意 sql 语句； -
addBatch(String sql)：把多条 sql 语句放到一个批处理中； -
executeBatch()：向数据库发送一批 sql 语句执行。
ResultSet 类：查询的结果集
- sql 语句的执行结果；
- Resultset 封装执行结果时，类似于表格的方式；
- ResultSet 对象维护了一个，指向表格数据行的游标，初始时，游标在第一行之前，调用 ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法，获取该行的数据。
- 该对象提供的都是，用于获取数据的 get 方法：
- 获取任意类型的数据：
- getObject(int index)；
- getObject(string columnName)；
- 获取指定类型的数据：
- getString(int index)；
- getString(String columnName)。
- 获取任意类型的数据：
- ResultSet 还提供了，对结果集进行滚动的方法：
- next()：移动到下一行；
- Previous()：移动到前一行；
- absolute(int row)：移动到指定行；
- beforeFirst()：移动 resultSet 的最前面；
- afterLast()：移动到 resultSet 的最后面。
释放资源
- JDBC 程序运行完，切记要释放程序在运行过程中，创建的与数据库进行交互的对象 ResultSet、Statement、Connection对象；
- Connection 对象，是非常稀有的资源，用完后必须马上释放，如果不能及时、正确的关闭，极易导致系统宕机；
- Connection 的使用原则：晚创建、早释放；
- 为确保资源释放代码能运行，资源释放代码，一定要放在 finally 语句中。
5. Statement 对象（不安全）
- 向数据库发送 SQL 语句，完成对数据库的增、删、改、查；
- executeUpdate 方法，用于向数据库发送增、删、改的 SQL 语句，执行完后，将会返回一个整数（数据库记录变化的条数）；
- executeQuery 方法，用于向数据库发送查询语句，返回结果集（ResultSet 对象）。
CRUD 操作
- create：使用 executeUpdate(String sql) 方法，插入数据；
Statement st = conn.createStatement();
String sql = "select * from user where id=1";
ResultSet rs = st.executeUpdate(sql);
while(rs.next()){
// 根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}
创建 JDBC 工具类：
image
- 在
src 目录下创建db.properties数据库配置文件:
# MySQL5.7 com.mysql.jdbc.Driver
# MySQL8
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456
- 新建 utils 包，新建类 JdbcUtils
package com.xxx.demo02.utils;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JdbcUtils {
public static String driver = null;
public static String url = null;
public static String username = null;
public static String password = null;
static {
try {
// 通过反射,读取数据库连接信息,得到输入流
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
// 创建属性集合
Properties props = new Properties();
// 读取流
props.load(in);
// 获取数据库配置属性
// 连接驱动
driver = props.getProperty("driver");
// URL地址
url = props.getProperty("url");
// 用户名
username = props.getProperty("username");
// 密码
password = props.getProperty("password");
// 加载驱动
Class.forName(driver);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
// 获取数据库连接对象
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, username, password);
}
// 释放资源：从后往前关闭
public static void release(Connection conn, Statement st, ResultSet rs) {
if (rs != null) {
try {
// 关闭结果集ResultSet对象
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (st != null) {
try {
// 关闭执行SQL命令的Statement对象
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (conn != null) {
try {
// 关闭Connection数据库连接对象
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
使用 Statement 对象，对数据库操作
- 插入数据
package com.xxx.demo02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestInsert {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
// 获取数据库连接
conn = JdbcUtils.getConnection();
// 获取SQL的执行对象
st = conn.createStatement();
// SQL语句:插入记录
String sql = "INSERT INTO `users`(`id`,`name`,`password`,`email`,`birthday`)" +
"VALUES(4,'测试','123','aa@aa.com','2020-1-1');";
// 执行SQL
int i = st.executeUpdate(sql);
if (i > 0) {
System.out.println("操作成功！");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JdbcUtils.release(conn, st, null);
}
}
}
- 删除数据：只更改 SQL 语句
String sql = "DELETE FROM `users` WHERE `id`=4;";
- 更新数据：只更改 SQL 语句
String sql = "UPDATE `users` SET `name`='测试2' WHERE `id`=2;";
- 查询数据
package com.xxx.demo02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestSelect {
public static void main(String[] args) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
// 获取数据库连接
conn = JdbcUtils.getConnection();
// 获取SQL的执行对象
st = conn.createStatement();
// SQL语句：查询
String sql = "SELECT * FROM `users` WHERE `id`=3;";
// 执行SQL：返回结果集
rs = st.executeQuery(sql);
if (rs.next()) {
System.out.println(rs.getString("name"));
System.out.println(rs.getDate("birthday"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JdbcUtils.release(conn, st, rs);
}
}
}
SQL 注入问题
- 通过巧妙的技巧来 拼接字符串，造成 SQL 短路，从而获取数据库数据；
package com.xxx.demo02.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SQL注入 {
public static void main(String[] args) {
// 正常登录
// login("zhansan", "123456");
// SQL注入
login("' or '1=1", "' or '1=1");
}
// 登录业务
public static void login(String name, String password) {
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
st = conn.createStatement();
// 注入方式登录后，SQL语句变为
// SELECT * FROM `users` WHERE `name`='' or '1=1' AND `password`='' or '1=1';
String sql = "SELECT * FROM `users` WHERE `name`='" +
name + "' AND `password`='" + password + "';";
rs = st.executeQuery(sql);
while (rs.next()) {
System.out.println(rs.getString("name"));
System.out.println(rs.getString("password"));
System.out.println("==================");
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
6. PreparedStatement 对象（安全）：推荐使用
-
PreparedStatement是Statement的子类；-
Connection.preparedStatement()方法，获得实例对象； -
PreperedStatement可以避免 SQL 注入。
-
-
Statement会使数据库，频繁编译 SQL，可能造成数据库缓冲区溢出； -
PreparedStatement可对 SQL 进行 预编译，提高执行效率； -
PreperedStatement对于 SQL 中的参数，允许使用占位符的形式进行替换，简化 SQL 语句的编写。
使用 PreparedStatement 对象对数据库操作
- 插入数据
package com.xxx.demo03;
import com.xxx.demo02.utils.JdbcUtils;
import java.sql.*;
import java.util.Date;
public class TestInsert {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
try {
// 获取数据库连接
conn = JdbcUtils.getConnection();
// 区别：获取SQL的执行对象
// 要执行的SQL命令，SQL中的参数使用?作为占位符
String sql = "INSERT INTO `users`(`id`,`name`,`password`,`email`,`birthday`)" +
"VALUES(?,?,?,?,?);";
// 对SQL进行预编译
// 通过conn对象,获取执行SQL命令的prepareStatement对象
st = conn.prepareStatement(sql);
// 为SQL语句中的参数赋值，索引是从1开始的
// id是int类型的
st.setInt(1, 5);
//name是varchar(字符串类型)
st.setString(2, "测试3");
//password是varchar(字符串类型)
st.setString(3, "123");
//email是varchar(字符串类型)
st.setString(4, "cc@cc.com");
// birthday是date类型
// sql.Date：数据库 util.Date：java new Date().getTime()：时间戳
st.setDate(5, new java.sql.Date(new Date().getTime()));
// 执行SQL
int i = st.executeUpdate();
if (i > 0) {
System.out.println("操作成功");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JdbcUtils.release(conn, st, null);
}
}
}
- 删除数据：变动部分
// SQL语句：删除
String sql = "DELETE FROM `users` WHERE `id`=?;";
// 对SQL进行预编译
st = conn.prepareStatement(sql);
// 为SQL语句中的参数赋值
st.setInt(1, 5);
- 更新数据：变动部分
// SQL语句：更新
String sql = "UPDATE `users` SET `name`=? WHERE `id`=?;";
// 对SQL进行预编译
st = conn.prepareStatement(sql);
// 第一个参数：名字
st.setString(1, "lisi");
// 第个的参数：id=3
st.setInt(2, 3);
- 查询数据
package com.xxx.demo03;
import com.xxx.demo02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class TestSelect {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
// 获取数据库连接
conn = JdbcUtils.getConnection();
// SQL语句：查询
String sql = "SELECT * FROM `users` WHERE `id`=?;";
// 对SQL进行预编译
st = conn.prepareStatement(sql);
// 为SQL语句中的参数赋值
st.setInt(1, 3);
// 执行SQL
rs = st.executeQuery();
while (rs.next()) {
System.out.println(rs.getString("name"));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
// 释放资源
JdbcUtils.release(conn, st, rs);
}
}
}
避免 SQL 注入
package com.xxx.demo02.utils;
import java.sql.*;
public class SQL注入 {
public static void main(String[] args) {
// 正常登录
// login("lisi", "123456");
// SQL注入
login("' or '1=1", "' or '1=1");
}
// 登录业务
public static void login(String name, String password) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try {
conn = JdbcUtils.getConnection();
// 参数会用引号包起来，防止注入
String sql = "SELECT * FROM `users` WHERE `name`=? AND `password`=?;";
st = conn.prepareStatement(sql);
st.setString(1, name);
st.setString(2, password);
rs = st.executeQuery();
while (rs.next()) {
System.out.println(rs.getString("name"));
System.out.println(rs.getString("password"));
System.out.println("==================");
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
- 原理：执行的时，参数会用引号包起来，并把参数中的引号，作为转义字符，从而避免了参数也作为条件的一部分。
