🍐 JDBC 基本概念

概念：Java DataBase Connectivity Java 数据库连接， Java 语言操作数据库

JDBC 本质：其实是官方（sun 公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar 包。我们可以使用这套接口（JDBC)编程，真正执行的代码是驱动jar包中的实现类。

image.png

🥝 快速入门

步骤

  1. 导入驱动 jar 包 mysql-connector-java-5.1.37-bin.jar
    1. 复制 mysql-connector-java-5.1.37-bin.jar 到项目的 libs 目录下
    2. 右键–>Add As Library

image.png

  1. 注册驱动
    1. Class.forName("com.mysql.jdbc.Driver");
  2. 获取数据库连接对象 Connection
    1. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "12345678");
  3. 定义 sql
    1. String sql = "update account set balance = 500 where id = 1";
  4. 获取执行 sql 语句的对象 Statement
    1. Statement stmt = conn.createStatement();
  5. 执行 sql，接受返回结果
    1. int count = stmt.executeUpdate(sql);
  6. 处理结果
  7. 释放资源
    1. stmt.close(); conn.close();
  1. Class.forName("com.mysql.jdbc.Driver");
  3. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
  5. String sql = "update account set balance = 500 where id = 1";
  7. Statement stmt = conn.createStatement();
  9. int count = stmt.executeUpdate(sql);
  11. System.out.println(count);
  13. stmt.close();
  14. conn.close();

详解各个对象

1.DriverManager：(驱动管理对象)

功能一：注册驱动

告诉程序该使用哪一个数据库驱动 jar

  1. static void registerDriver(Driver driver) :注册与给定的驱动程序 DriverManager 。 
  2. 写代码使用：  Class.forName("com.mysql.jdbc.Driver");
  4. 通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
  5. static {
  6.         try {
  7.                 java.sql.DriverManager.registerDriver(new Driver());
  8.     } catch (SQLException E) {
  9.                 throw new RuntimeException("Can't register driver!");
  10.         }
  11. }

注意：mysql5 之后的驱动 jar 包可以省略注册驱动的步骤。

功能二：获取数据库连接

  1. static Connection getConnection(String url, String user, String password)

参数：

  • url：指定连接的路径
    • 语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
    • 例子：jdbc:mysql://localhost:3306/db3
    • 细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称 ，默认书写有：localhost:3306
  • user：用户名
  • password：密码

2.Connection：(数据库连接对象)

  1. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
  1. 获取执行 sql 的对象 ```java Statement createStatement()

或

PreparedStatement prepareStatement(String sql)

  3. 2. 管理事务：
  5. - 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为 false，即开启事务
  6. - 提交事物：commit()
  7. - 回滚事物：rollback()
  10. <a name="vgSI9"></a>
  11. ### 3.Statement（执行 sql 的对象）静态 sql
  13. 1. boolean execute(String sql)：可以执行任意的 sql 语句
  14. 1. int executeUpdate(String sql)：执行 DML (insert、 update、 delete)语句、DDL(create， alter、drop) 语句
  15.    1. 返回值：影响的行数，可以通过这个影响的行数判断 DML 语句是否执行成功返回值＞0 的则执行成功，反之，则失败。
  16. 3. ResultSet executeQuery(String sql)：执行 DQL (select) 语句
  18. 练习：
  20. 1. account 表 添加一条记录
  21. 1. account 表 修改记录
  22. 1. account 表 删除一条记录
  24. ```java
  25. Statement stmt = null;
  26. Connection conn = null;
  27. try {
  28.     //1.注册驱动
  29.     //Class.forName("com.mysql.cj.jdbc.Driver");
  30.     //2.定义sql
  31.     String sql = "insert into sign_into values(null,'王五',3000)";
  32.     //3.获取Connection对象
  33.     conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "12345678");
  34.     //4.获取执行sql的对象 Statement
  35.     stmt = conn.createStatement();
  36.     //5.执行sql
  37.     int count = stmt.executeUpdate(sql);
  38.     //6.处理结果
  39.     System.out.println(count);
  40.     if (count > 0) {
  41.         System.out.println("添加成功");
  42.     } else {
  43.         System.out.println("添加失败");
  44.     }
  45. } catch (ClassNotFoundException e) {
  46.     e.printStackTrace();
  47. } catch (SQLException e) {
  48.     e.printStackTrace();
  49. }finally {
  50.     if(stmt != null){
  51.         try {
  52.             stmt.close();
  53.         } catch (SQLException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  58.     if(conn != null){
  59.         try {
  60.             conn.close();
  61.         } catch (SQLException e) {
  62.             e.printStackTrace();
  63.         }
  64.     }
  65. }

4.ResultSet（结果集对象, 封装查询结果）

  • boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾 (是否有数据)，如果是，则返回 false，如果不是则返回 true
  • getXxx(参数): 获取数据
    • Xxx：代表数据类型 如： int getInt() , String getString()
    • 参数：
      • int：代表列的编号, 从 1 开始 如： getString(1)
      • String：代表列名称。 如： getDouble(“balance”)

注意：使用下面的步骤：

  1. 游标向下移动一行
  2. 判断是否有数据

  3. 获取数据

    1. while(rs.next()){
    2.  int id = rs.getInt(1);
    3.  String name = rs.getString("name");
    4.  double balance = rs.getDouble(3);
    6.  System.out .println(id + "---" + name + "---" + balance);
    7. }

    ```java package JDBCpractice.test;

import java.sql.*;

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

  1.     Connection conn = null;
  2.     Statement statement = null;
  3.     try {
  4.         conn = DriverManager.getConnection("jdbc:mysql:///tmp", "root", "root");
  5.         statement = conn.createStatement();
  6.         String sql = "select ename from emp";
  7.         ResultSet resultSet = statement.executeQuery(sql);
  8.         while(resultSet.next()){
  9.             System.out.println(resultSet.getString(1));
  10.         }
  11.     } catch (SQLException throwables) {
  12.         throwables.printStackTrace();
  13.     } finally {
  15.         if(conn != null){
  16.             try {
  17.                 conn.close();
  18.             }catch (SQLException e){
  19.                 System.out.println(e);
  20.             }
  21.         }
  23.         if(statement != null){
  24.             try {
  25.                 statement.close();
  26.             }catch (SQLException e){
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.     }
  32. }

}

  3. **练习：定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。**
  5. 1. 定义Emp类
  6. 1. 定义方法 public List<Emp> findAll(){ }
  7. 1. 实现方法 select * from emp
  8. ```java
  9. public class JDBCDemo8 {
  11.     public static void main(String[] args) {
  12.         List<Emp> list = new JDBCDemo8().findAll2();
  13.         System.out.println(list);
  14.         System.out.println(list.size());
  15.     }
  16.     /**
  17.      * 查询所有emp对象
  18.      * @return
  19.      */
  20.     public List<Emp> findAll(){
  21.         Connection conn = null;
  22.         Statement stmt = null;
  23.         ResultSet rs = null;
  24.         List<Emp> list = null;
  25.         try {
  26.             //1.注册驱动
  27.             Class.forName("com.mysql.jdbc.Driver");
  28.             //2.获取连接
  29.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  30.             //3.定义sql
  31.             String sql = "select * from emp";
  32.             //4.获取执行sql的对象
  33.             stmt = conn.createStatement();
  34.             //5.执行sql
  35.             rs = stmt.executeQuery(sql);
  36.             //6.遍历结果集，封装对象，装载集合
  37.             Emp emp = null;
  38.             list = new ArrayList<Emp>();
  39.             while(rs.next()){
  40.                 //获取数据
  41.                 int id = rs.getInt("id");
  42.                 String ename = rs.getString("ename");
  43.                 int job_id = rs.getInt("job_id");
  44.                 int mgr = rs.getInt("mgr");
  45.                 Date joindate = rs.getDate("joindate");
  46.                 double salary = rs.getDouble("salary");
  47.                 double bonus = rs.getDouble("bonus");
  48.                 int dept_id = rs.getInt("dept_id");
  49.                 // 创建emp对象,并赋值
  50.                 emp = new Emp();
  51.                 emp.setId(id);
  52.                 emp.setEname(ename);
  53.                 emp.setJob_id(job_id);
  54.                 emp.setMgr(mgr);
  55.                 emp.setJoindate(joindate);
  56.                 emp.setSalary(salary);
  57.                 emp.setBonus(bonus);
  58.                 emp.setDept_id(dept_id);
  60.                 //装载集合
  61.                 list.add(emp);
  62.             }
  64.         } catch (ClassNotFoundException e) {
  65.             e.printStackTrace();
  66.         } catch (SQLException e) {
  67.             e.printStackTrace();
  68.         }finally {
  69.             if(rs != null){
  70.                 try {
  71.                     rs.close();
  72.                 } catch (SQLException e) {
  73.                     e.printStackTrace();
  74.                 }
  75.             }
  77.             if(stmt != null){
  78.                 try {
  79.                     stmt.close();
  80.                 } catch (SQLException e) {
  81.                     e.printStackTrace();
  82.                 }
  83.             }
  85.             if(conn != null){
  86.                 try {
  87.                     conn.close();
  88.                 } catch (SQLException e) {
  89.                     e.printStackTrace();
  90.                 }
  91.             }
  92.         }
  93.         return list;
  94.     }
  95. }

5.PreparedStatement：执行 sql 的对象 (动态 sql、预处理)

为什么要使用PreparedStatement，而不用Statement？
SQL 注入问题：在拼接 sql 时，有一些 sql 的特殊关键字参与字符串的拼接。会造成安全性问题

  1. 1. 输入用户随便，输入密码：a' or 'a' = 'a
  2. 2. sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
  1. 解决 sql 注入问题：使用 PreparedStatement 对象来解决
  2. 预编译的 SQL：参数使用? 作为占位符
  3. 步骤：
    1. 导入驱动 jar 包 mysql-connector-java-5.1.37-bin.jar
    2. 注册驱动
    3. 获取数据库连接对象 Connection
    4. 定义 sql
      1. 注意：sql 的参数使用？作为占位符。 如：select * from user where username = ? and password = ?;
    5. 获取执行 sql 语句的对象 PreparedStatement Connection.prepareStatement(String sql)
    6. 给？赋值：
      1. 方法： setXxx(参数 1, 参数 2)
        1. 参数 1：？的位置编号 从 1 开始
        2. 参数 2：？的值
    7. 执行 sql，接受返回结果，不需要传递 sql 语句
    8. 处理结果
    9. 释放资源
  4. 注意：后期都会使用 PreparedStatement 来完成增删改查的所有操作
    1. 可以防止 SQL 注入
    2. 效率更高 ```java package JDBCpractice.test;

import java.sql.*;

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

  1.     Connection conn = null;
  2.     Statement statement = null;
  3.     try {
  4.         conn = DriverManager.getConnection("jdbc:mysql:///tmp", "root", "root");
  5.         String sql = "select ename from emp where id = ?";
  6.         PreparedStatement preparedStatement = conn.prepareStatement(sql);
  7.         preparedStatement.setInt(1,1001);
  8.         ResultSet resultSet = preparedStatement.executeQuery();
  11.         while(resultSet.next()){
  12.             System.out.println(resultSet.getString(1));
  13.         }
  14.     } catch (SQLException throwables) {
  15.         throwables.printStackTrace();
  16.     } finally {
  18.         if(conn != null){
  19.             try {
  20.                 conn.close();
  21.             }catch (SQLException e){
  22.                 System.out.println(e);
  23.             }
  24.         }
  26.         if(statement != null){
  27.             try {
  28.                 statement.close();
  29.             }catch (SQLException e){
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }

}

  3. <a name="06663626"></a>
  4. ## 抽取 JDBC 工具类 ： JDBCUtils
  6. 目的：简化书写
  8. 分析：
  10. 1. 注册驱动也抽取
  11. 1. 抽取一个方法获取连接对象
  12. 1. 需求：不想传递参数（麻烦），还得保证工具类的通用性。
  13. 1. 解决：配置文件

url=jdbc:mysql:///tmp user=root password=root driver=com.mysql.jdbc.Driver

  2. 3. 抽取一个方法释放资源
  3. ```java
  4. package JDBCpractice.util;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileReader;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.net.URL;
  11. import java.sql.*;
  12. import java.util.Properties;
  14. public class JDBCUtils {
  15.     private static String url;
  16.     private static String user;
  17.     private static String password;
  18.     private static String driver;
  22.     static{
  25.         try {
  27.             Properties pro = new Properties();
  30.             ClassLoader classLoader = JDBCUtils.class.getClassLoader();
  31.             InputStream is = classLoader.getResourceAsStream("jdbc.properties");
  32.             pro.load(is);
  35.             url = pro.getProperty("url");
  36.             user = pro.getProperty("user");
  37.             password = pro.getProperty("password");
  38.             driver = pro.getProperty("driver");
  40.             Class.forName(driver);
  41.         } catch (IOException e) {
  42.             e.printStackTrace();
  43.         } catch (ClassNotFoundException e) {
  44.             e.printStackTrace();
  45.         }
  46.     }
  51.     public static Connection getConnection() throws SQLException {
  52.         return DriverManager.getConnection(url,user,password);
  53.     }
  57.     public static void close(Statement stmt,Connection conn){
  58.         if (stmt != null){
  59.             try {
  60.                 stmt.close();
  61.             } catch (SQLException throwables) {
  62.                 throwables.printStackTrace();
  63.             }
  64.         }
  66.         if (conn != null){
  67.             try {
  68.                 conn.close();
  69.             } catch (SQLException throwables) {
  70.                 throwables.printStackTrace();
  71.             }
  72.         }
  74.     }
  77.     public static void close(ResultSet rs, Statement stmt, Connection conn){
  79.         if (rs != null){
  80.             try {
  81.                 rs.close();
  82.             } catch (SQLException throwables) {
  83.                 throwables.printStackTrace();
  84.             }
  85.         }
  87.         if (stmt != null){
  88.             try {
  89.                 stmt.close();
  90.             } catch (SQLException throwables) {
  91.                 throwables.printStackTrace();
  92.             }
  93.         }
  95.         if (conn != null){
  96.             try {
  97.                 conn.close();
  98.             } catch (SQLException throwables) {
  99.                 throwables.printStackTrace();
  100.             }
  101.         }
  103.     }
  105.     public static void close(ResultSet rs,  PreparedStatement preparedStatement, Connection conn){
  107.         if (rs != null){
  108.             try {
  109.                 rs.close();
  110.             } catch (SQLException throwables) {
  111.                 throwables.printStackTrace();
  112.             }
  113.         }
  115.         if (preparedStatement != null){
  116.             try {
  117.                 preparedStatement.close();
  118.             } catch (SQLException throwables) {
  119.                 throwables.printStackTrace();
  120.             }
  121.         }
  123.         if (conn != null){
  124.             try {
  125.                 conn.close();
  126.             } catch (SQLException throwables) {
  127.                 throwables.printStackTrace();
  128.             }
  129.         }
  131.     }
  134. }

练习

需求：

  1. 通过键盘录入用户名和密码
  2. 判断用户是否登录成功 
    1. select * from user where username = "" and password = "";
    如果这个sql有查询结果，则成功，反之，则失败

创建数据库表 user

  1. CREATE TABLE USER(
  2. id INT PRIMARY KEY AUTO_INCREMENT,
  3. username VARCHAR(32),
  4. PASSWORD VARCHAR(32)
  5. );
  7. INSERT INTO USER VALUES(NULL,'zhangsan','123');
  8. INSERT INTO USER VALUES(NULL,'lisi','234');

代码实现

  1. package JDBCpractice.util;
  3. import java.lang.reflect.Field;
  4. import java.sql.Connection;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.util.Scanner;
  10. public class UserLoginTest {
  12.     public static void main(String[] args) {
  14.         Scanner sc = new Scanner(System.in);
  16.         System.out.println("请输入账号:");
  17.         String user = sc.next();
  19.         System.out.println("请输入密码");
  20.         String password = sc.next();
  23.         boolean b = new UserLoginTest().userLogin(user, password);
  25.         if(b){
  26.             System.out.println("登陆成功");
  27.         }else {
  28.             System.out.println("登陆失败");
  29.         }
  30.     }
  32.     public boolean userLogin(String user,String password){
  34.         if (user == null || password == null){
  35.             return false;
  36.         }
  40.         Connection conn = null;
  41.         PreparedStatement preparedStatement =  null;
  42.         ResultSet rs = null;
  44.         try {
  45.             conn = JDBCUtils.getConnection();
  46.             String sql = "select * from user where username = ? and password = ?";
  47.             preparedStatement = conn.prepareStatement(sql);
  48.             preparedStatement.setString(1,user);
  49.             preparedStatement.setString(2,password);
  50.             rs= preparedStatement.executeQuery();
  52.             return rs.next();
  53.         } catch (SQLException throwables) {
  54.             throwables.printStackTrace();
  55.         }finally{
  56.             JDBCUtils.close(rs,preparedStatement,conn);
  57.         }
  58.         return false;
  59.     }
  61. }

🍠 JDBC 控制事务

事务：一个包含多个步骤的业务操作。如果这个业务操作被事务管理，则这多个步骤要么同时成功，要么同时失败。

操作：

  1. 开启事务
  2. 提交事务
  3. 回滚事务

使用 Connection 对象来管理事务

  • 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为 false，即开启事务
    • 在执行 sql 之前开启事务
  • 提交事务：commit()
    • 当所有 sql 都执行完提交事务
  • 回滚事务：rollback()
    • 在 catch 中回滚事务

代码：

  1. public class JDBCDemo10 {
  3.     public static void main(String[] args) {
  4.         Connection conn = null;
  5.         PreparedStatement pstmt1 = null;
  6.         PreparedStatement pstmt2 = null;
  8.         try {
  10.             conn = JDBCUtils.getConnection();
  12.             conn.setAutoCommit(false);//开始事务
  16.             String sql1 = "update account set balance = balance - ? where id = ?";
  18.             String sql2 = "update account set balance = balance + ? where id = ?";
  20.             pstmt1 = conn.prepareStatement(sql1);
  21.             pstmt2 = conn.prepareStatement(sql2);
  23.             pstmt1.setDouble(1,500);
  24.             pstmt1.setInt(2,1);
  26.             pstmt2.setDouble(1,500);
  27.             pstmt2.setInt(2,2);
  29.             pstmt1.executeUpdate();
  31.             int i = 3/0;
  33.             pstmt2.executeUpdate();
  35.             conn.commit(); //提交事务
  36.         } catch (Exception e) {
  38.             try {
  39.                 if(conn != null) {
  40.                     conn.rollback();  //回滚事务
  41.                 }
  42.             } catch (SQLException e1) {
  43.                 e1.printStackTrace();
  44.             }
  45.             e.printStackTrace();
  46.         }finally {
  47.             JDBCUtils.close(pstmt1,conn);
  48.             JDBCUtils.close(pstmt2,null);
  49.         }
  50.     }
  52. }