MySQL 入门（五）

2022-02-19 本文已影响0人 yjtuuige

十、JDBC（重点）

1. 数据库驱动

应用程序通过驱动，连接数据库，如：MySQL 驱动、Oracle 驱动；

image

2. JDBC 介绍

JDBC ：Java Data Base Connectivity（Java 数据库连接），是 Java 操作数据库的统一规范，主要由接口组成；
组成 JDBC 的２个包：java.sql、javax.sql；
开发 JDBC 应用需要以上 2 个包的支持外，还需要导入相应 JDBC 的数据库实现（即数据库驱动）；
MySQL 8.028 驱动
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。
连接数据库 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;

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();
        }
    }
}

原理：执行的时，参数会用引号包起来，并把参数中的引号，作为转义字符，从而避免了参数也作为条件的一部分。

MySQL 入门（五）

十、JDBC（重点）

1. 数据库驱动

2. JDBC 介绍

3. 编写 JDBC 程序

4. 对象说明

5. Statement 对象（不安全）

6. PreparedStatement 对象（安全）：推荐使用

猜你喜欢

热点阅读