基本概念

java DataBase Connectivity —> java数据库连接 —> java语言操作数据库

JDBC本质

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

快速入门

步骤

  1. 导入驱动jar包

下载jar包
https://mvnrepository.com/ Mysql connecter java
https://mvnrepository.com/artifact/mysql/mysql-connector-java/8.0.21

  1. 注册驱动
  2. 获取数据库的链接对象 Connection
  3. 定义sql
  4. 获取执行sql语句的对象 Statement
  5. 执行sql ， 接收返回结果
  6. 处理结果
  7. 释放资源

    实现一个操作

    image.pngimage.png
    image.png
    再创建一个空的项目
    image.png
    image.png
    image.pngfinish
    弹出窗口
    image.png
    next
    image.png
    finish -> OK
    创建一个包
    image.png
    为其命名cn.itcast.jdbc
    image.png
    tips： 如果创建出来的不是这样分开的包，点击右上角小齿轮 -> 取消勾选的Compact Middle Package
    image.png
    image.png

包有了之后写类
image.png
image.png
image.png

导入驱动jar包

连接什么数据库就用什么jar包，这里以MySQL为例
mysql-connector-java-8.0.21.jar
image.png
建一个文件夹libs方便管理jar包，因为做项目时有好多jar包
把jar包复制到libs里面，从计算机里面找到jar包，ctrl C复制到libs Ctrl V
弹出：
image.png
image.png
image.pngOK

总结

复制jar包到项目的libs目录下
右键—>add as Library

注册驱动

image.png这里有一个ClassNotFound的异常 Alt+Enter抛出去就可以了
image.png 抛出之后删去ClassNotFoundimage.png

获取数据库的链接对象

image.png

image.png

database输入错误 报错

image.png
Exception in thread “main” java.sql.SQLSyntaxErrorException: Unknown database ‘pet’

地域时间未设置 报错

Exception in thread “main” java.sql.SQLException: The server time zone value ‘�й���׼ʱ��’ is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the ‘serverTimezone’ configuration property) to use a more specifc time zone value if you want to utilize time zone support.
修改后：
image.png
这是在使用MySQL 8.0以上版本（MySQL连接驱动和版本都是8.0以上）的时候出现的问题错误

  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.Statement;
  7. public class jdbcDemo1 {
  8.     public static void main(String[] args) throws Exception {
  9.         //导入jar包
  10.         //注册驱动
  11.         Class.forName("com.mysql.cj.jdbc.Driver");
  12.         //获取数据库的链接对象
  13.         Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/myfirsttest?serverTimezone=Asia/Shanghai","root","123456");
  14.         //定义sql语句
  15.         String sql = "update account set balance = 500 where id = 1";
  16.         //获取执行sql的对象Statement
  17.         Statement stmt = conn.createStatement();
  18.         //执行sql
  19.         int count = stmt.executeUpdate(sql);
  20.         //处理结果
  21.         System.out.println(count);
  22.         //释放资源
  23.         stmt.close();
  24.         conn.close();
  25.     }
  26. }
  28. 结果：
  29. 1
  31. Process finished with exit code 0

详解各个对象

  1. DriverManager：驱动管理对象
  2. Connection ：数据库连接对象
  3. Statement：执行sql的对象
  4. ResultSet：结果集对象
  5. PreparedStatement：执行sql的对象

    DriverManager

    驱动管理对象
    功能：

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

    static void registerDriver(Driver diver) ：注册与给定的驱动程序DiverManager。
    写代码使用：Class.forName(“com.mysql.cj.jdbc.Driver”);
    通过查看源码发现：在com.mysql.cj.jdbc.Driver类中存在静态代码块
    image.png

注释掉后发现程序依旧可以运行，why？
image.png
注释掉后被MySQL5+自动帮忙注册驱动了，所以MySQL5之后的驱动jar包可以省略注册驱动的步骤

获取数据库链接

方法

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

参数：

url ：指定连接的路径
语法：jdbc : mysql:// ip地址（域名）: 端口号 / 数据库名称
🌰： jdbc:mysql:// localhost : 3306 / myfirsttest
细节：如果连接的是本机MySQL服务器，并且MySQL服务默认端口是3360，则url可简写为： jdbc:mysql:///数据库名称
image.png
user：用户名
password：密码

Connection

数据库链接对象

  1. 功能：
    1. 获取执行sql的对象

Statement createStatement()：获取一个Statemen对象，用于将sql语句发送到数据库
PreparedStatement preparedStatement(String sql)

  1. 管理事务
    1. 开启事务：setAutoCommit(boolean autoCommit) 调用该方法设置参数为false，即开启事务
    2. 提交事务：commit()
    3. 回滚事务：rollback()

      Statement

      执行SQL的对象
  1. 执行sql
    1. boolean execute(String sql) : 可以执行任意的sql （了解）
    2. int executeUpdate(Strirng sql) : 执行DML（insert update delete）语句、DDL（create alter drop）语句

返回值：影响的行数
image.png影响两行
image.png
可以通过这个影响的行数来判断DML语句是否执行成功 返回值>0,则成功，反之失败
c. ResultSet executeQuery (String sql) : 执行DQL （select）语句，返回一个结果及对象（后面讲

🍕练习：

account表 添加一条记录

注册驱动的时候发现一个异常，抓一下 try/catch一下
image.png
image.png
获取Connection对象时候再抓一个异常
image.png
抓完之后出现一个catch
image.png
释放资源
image.png
因为stmt在try作用域里面，相当于一个局部变量。
此时要提升它的作用域，把它提升到try的外面

  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /*
  9.  * account表 添加一条记录 insert 语句的一个练习
  10.  * */
  11. public class JDBCDemo2 {
  12.     public static void main(String[] args){
  13.         Statement stmt = null;
  14.         Connection conn = null;
  16.         //不用导入jar包了，可省略
  18.         try {
  19.             //1. 注册驱动
  20.             Class.forName("com.mysql.cj.jdbc.Driver");
  21.             //2.定义sql
  22.             String sql = "insert into account values(3,'王五','2020-10-01',3000) ";
  23.             //3.获取Connection对象
  24.             conn = DriverManager.getConnection("jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai","root","123456");
  25.             //4.获取执行sql的对象Statement
  26.             stmt = conn.createStatement();
  27.             //5.执行sql
  28.             int count = stmt.executeUpdate(sql); //count 影响的行数
  29.             //6.处理结果
  30.             System.out.println(count);
  31.             if (count>0){
  32.                 System.out.println("添加成功");
  33.             }else {
  34.                 System.out.println("添加失败");
  35.             }
  38.         } catch (ClassNotFoundException e) {
  39.             e.printStackTrace();
  40.         } catch (SQLException e) {
  41.             e.printStackTrace();
  42.         }finally {
  43.             //stmt.close(); 如果中间出错（如：密码错误），那么会返回一个空指针
  44.             //7.释放资源
  45.             //避免空指针异常
  46.             if (stmt != null){
  47.                 try {
  48.                     stmt.close();
  49.                 } catch (SQLException e) {
  50.                     e.printStackTrace();
  51.                 }
  52.             }
  53.             //复制粘贴一下 判断conn
  54.             if (conn != null){
  55.                 try {
  56.                     conn.close();
  57.                 } catch (SQLException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.             }
  62.         }
  63.     }
  65. 结果：
  66. 1
  67. 添加成功

account表 修改记录

  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /*
  9. * account表修改记录 王五金额修改为200
  10. * */
  11. public class JDBCDemo3 {
  12.     public static void main(String[] args) {
  13.         Connection conn = null;
  14.         Statement stmt = null;
  15.         try {
  16.             //1.注册驱动
  17.             Class.forName("com.mysql.cj.jdbc.Driver");
  18.             //2.获取连接对象
  19.             conn = DriverManager.getConnection("jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai", "root", "123456");
  20.             //3.定义sql
  21.             String sql = "update account set balance = 200 where id = 3";
  22.             //4.获取执行sql对象
  23.             stmt = conn.createStatement();
  24.             //5.执行sql
  25.             int count = stmt.executeUpdate(sql);
  26.             //6.处理结果
  27.             System.out.println(count);
  28.             if (count > 0) {
  29.                 System.out.println("更新修改成功");
  30.             } else {
  31.                 System.out.println("更新修改失败");
  32.             }
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             //释放资源 防止空指针异常
  39.             if (stmt != null) {
  40.                 try {
  41.                     stmt.close();
  42.                 } catch (SQLException e) {
  43.                     e.printStackTrace();
  44.                 }
  46.                 if (conn != null) {
  47.                     try {
  48.                         conn.close();
  49.                     } catch (SQLException e) {
  50.                         e.printStackTrace();
  51.                     }
  52.                 }
  53.             }
  54.         }
  55.     }}

account表 删除一套记录

复制上面的代码，改动一下第三步的语句
delete from account where id = 3

ResultSet

结果集对象，封装查询结果
就是把这些结果对象拿出来
游标（类似指针）

image.png

游标默认指向表头（第一行）
此时不能取数据

作用过程涉及两类方法

next()

boolean类型的值，游标从当前位置向下移动一行，判断当前行是否是最后一行末尾（是否有数据），如果是则返回false，反之true

getXxx(参数)

获取数据
一次获取某一行的某一列的数据
Xxx： 数据类型 eg：int getInt()，String getString()
参数：

  1.   1. Int 代表列的编号，从**1**开始   eg：getInt(1)
  2.   1. String：代表列的名称           eg：getString("balance")

范例

  1. package cn.itcast.jdbc;
  3. import java.sql.*;
  5. public class JDBCDemo6 {
  6.     public static void main(String[] args) {
  7.         Connection conn = null;
  8.         Statement stmt = null;
  9.         ResultSet rs = null;
  10.         try {
  11.             //1.注册驱动
  12.             Class.forName("com.mysql.cj.jdbc.Driver");
  13.             //2.获取连接对象
  14.             conn = DriverManager.getConnection("jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai", "root", "123456");
  15.             //3.定义sql
  16.             String sql = "select * from account";
  17.             //4.获取执行sql对象
  18.             stmt = conn.createStatement();
  19.             //5.执行sql
  20.             rs = stmt.executeQuery(sql);
  21.             //6.处理结果
  22.             //6.1让游标向下移动一行
  23.             rs.next();
  24.             //6.2获取数据
  25.             int id = rs.getInt(1);
  26.             String name= rs.getString("name");
  27.             double balance = rs.getDouble(3);
  28.             System.out.println(id+"---"+name+"---"+balance);
  30.         } catch (ClassNotFoundException e) {
  31.             e.printStackTrace();
  32.         } catch (SQLException e) {
  33.             e.printStackTrace();
  34.         } finally {
  35.             //释放资源 防止空指针异常
  36.             if (stmt != null) {
  37.                 try {
  38.                     stmt.close();
  39.                 } catch (SQLException e) {
  40.                     e.printStackTrace();
  41.                 }
  43.                 if (rs != null) {
  44.                     try {
  45.                         rs.close();
  46.                     } catch (SQLException e) {
  47.                         e.printStackTrace();
  48.                     }
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }
  56. 结果：
  57. 2---ls---2000.0

使用步骤

  1. 游标向下移动一行
  2. 判断是否有数据 ： boolean next() 有数据true

  3. 获取数据

    1. while(rs.next())  //循环判断结果集是否有数据
    2.          {
    3.              //6.2获取数据
    4.              int id = rs.getInt(1);
    5.              String name= rs.getString("name");
    6.              double balance = rs.getDouble(3);
    7.              System.out.println(id+"---"+name+"---"+balance);
    8.          }

    eg：
    定义一个方法，查询account表的数据，将其封装为对象，然后装载集合，返回。打印

  4. 定义account类

  5. 定义方法 public List findAll(){}
  6. 实现方法 select * from account ;

image.png

  1. package cn.itcast.domain;
  2. //封装account表数据的JavaBean
  3. public class account {
  4.     private int id;
  5.     private String name;
  6.     private double balance;
  8.     //右键-->Generate  -->Ctrl全选
  10.     public int getId() {
  11.         return id;
  12.     }
  14.     public void setId(int id) {
  15.         this.id = id;
  16.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  22.     public void setName(String name) {
  23.         this.name = name;
  24.     }
  26.     public double getBalance() {
  27.         return balance;
  28.     }
  30.     public void setBalance(double balance) {
  31.         this.balance = balance;
  32.     }
  34.     @Override
  35.     public String toString() {
  36.         return "account{" +
  37.                 "id=" + id +
  38.                 ", name='" + name + '\'' +
  39.                 ", balance=" + balance +
  40.                 '}';
  41.     }
  42. }
  1. package cn.itcast.jdbc;
  3. import cn.itcast.domain.account;
  5. import java.sql.*;
  6. import java.util.*;
  8. /*
  9. * 定义一个方法，查询account表的数据，将其封装为对象，然后装载集合，返回。
  10. * */
  11. public class JDBCDemo8 {
  12.     public static void main(String[] args) {
  13.         List<account> list = new JDBCDemo8().findAll();
  14.         System.out.println(list);
  16.     }
  17.     //查询所有emp对象
  18.     //@return
  19.     public List<account> findAll(){
  20.         ResultSet re = null;
  21.         Statement stmt = null;
  22.         Connection conn = null;
  23.         List<account> list = null;
  24.         try {
  25.             //1.注册驱动
  26.             Class.forName("com.mysql.cj.jdbc.Driver");
  27.             //2.获取链接
  28.             conn = DriverManager.getConnection("jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai","root","123456");
  29.             //3.定义sql
  30.             String sql = "select * from account";
  31.             //4.获取执行sql的对象
  32.            stmt = conn.createStatement();
  33.             //5.执行sql
  34.             re = stmt.executeQuery(sql);
  35.             //6.遍历结果集，封装对象，装载集合
  36.             account ac = null;
  37.              list = new ArrayList<account>();
  38.             while(re.next()){
  39.                 //获取数据
  40.                 int id = re.getInt("id");
  41.                 String name = re.getString("name");
  42.                 double balance = re.getDouble("balance");
  43.                 //创建account对象
  44.                 ac = new account();
  45.                 ac.setId(id);
  46.                 ac.setBalance(balance);
  47.                 ac.setName(name);
  48.                 //装载集合
  49.                 list.add(ac);
  50.             }
  52.             //list.forEach(System.out::println);
  54.         } catch (ClassNotFoundException e) {
  55.             e.printStackTrace();
  56.         } catch (SQLException e) {
  57.             e.printStackTrace();
  58.         }finally {
  59.             if (re != null){
  60.                 try {
  61.                     re.close();
  62.                 } catch (SQLException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  66.             if (stmt != null){
  67.                 try {
  68.                     stmt.close();
  69.                 } catch (SQLException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.             }
  73.             if (conn != null){
  74.                 try {
  75.                     conn.close();
  76.                 } catch (SQLException e) {
  77.                     e.printStackTrace();
  78.                 }
  79.             }
  80.         }
  81.         return list;
  82.     }
  83. }

PreparedStatement

Statement的衍生，执行SQL的对象（功能比Statement更强）

抽取JDBC工具类

JDBCUtils

简化书写

分析

  1. 注册驱动也抽取
  2. 抽取一个方法获取连接对象

需求：不想传递参数（麻烦），还得保证工具类的通用性。
解决：配置文件
定义一个jdbc.properties配置文件，
其中记录：
url=
user=
password=

  1. 抽取一个方法释放资源

image.png

  1. package cn.itcast.util;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.net.URL;
  6. import java.sql.*;
  7. import java.util.Properties;
  9. //jdbc工具类
  10. public class JDBCUtils {
  11.     //声明三个成员变量
  12.     private static String url;
  13.     private static String user;
  14.     private static String password;
  15.     private static String driver;
  16.     /**
  17.      * 文件的读取，只需要读取一次即可拿到这些值.使用静态代码块
  18.      */
  19.     static{
  20.         //读取资源文件，获取值。
  22.         try {
  23.             //1.创建Properties集合类
  24.             Properties pro = new Properties();
  25.             //获取src路径下的文件的方式--->ClassLoader 类加载器，加载字节码文件径内存，且获取src下的文件路径
  26.             ClassLoader classLoader = JDBCUtils.class.getClassLoader();
  27.             URL res = classLoader.getResource("jdbc.properties");
  28.             //URL 表示一个统一资源定位符 ↑ 定义了一个文件的绝对路径
  29.             String path = res.getPath();
  30.             System.out.println(path);
  31.             //2.加载文件
  32.             // pro里load方法load（Reader字符流 /InputStream字节流）
  33.             //pro.load(new FileReader("src/jdbc.properties"));
  34.             pro.load(new FileReader(path));
  35.             //3.获取属性 赋值
  36.             url = pro.getProperty("url");
  37.             user = pro.getProperty("user");
  38.             password = pro.getProperty("password");
  39.             driver = pro.getProperty("driver");
  40.             try {
  41.                 //4.注册驱动
  42.                 Class.forName(driver);
  43.             } catch (ClassNotFoundException e) {
  44.                 e.printStackTrace();
  45.             }
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         }
  50.     }
  52.     /**
  53.      * 获取连接
  54.      * @return 连接对象
  55.      */
  56.     // 工具类有个特点，所有方法都是静态的，方便调用
  57.     public static Connection getConnection() throws SQLException {
  58.         return DriverManager.getConnection(url,user,password);
  59.     }
  61.     /**
  62.      * 关闭/释放资源方法
  63.      * 没有返回值
  64.      */
  65.     public static void close(Statement stmt, Connection conn){
  66.         if (stmt != null){
  67.             try {
  68.                 stmt.close();
  69.             } catch (SQLException e) {
  70.                 e.printStackTrace();
  71.             }
  72.         }
  73.         if (conn != null){
  74.             try {
  75.                 conn.close();
  76.             } catch (SQLException e) {
  77.                 e.printStackTrace();
  78.             }
  79.         }
  81.     }
  83.     public static void close(ResultSet rs , Statement stmt, Connection conn){
  84.         if (rs != null){
  85.             try {
  86.                 rs.close();
  87.             } catch (SQLException e) {
  88.                 e.printStackTrace();
  89.             }
  90.         }
  91.         if (stmt != null){
  92.             try {
  93.                 stmt.close();
  94.             } catch (SQLException e) {
  95.                 e.printStackTrace();
  96.             }
  97.         }
  98.         if (conn != null){
  99.             try {
  100.                 conn.close();
  101.             } catch (SQLException e) {
  102.                 e.printStackTrace();
  103.             }
  104.         }
  106.     }
  107. }

image.png

  1. url = jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai
  2. user = root
  3. password = 123456
  4. driver = com.mysql.cj.jdbc.Driver

演示JDBC工具类

  1. package cn.itcast.jdbc;
  3. import cn.itcast.domain.account;
  4. import cn.itcast.util.JDBCUtils;
  6. import java.sql.*;
  7. import java.util.ArrayList;
  8. import java.util.List;
  10. public class JDBCDemo8_1 {
  11.     public static void main(String[] args) {
  12.         List<account> list = new JDBCDemo8_1().findAll2();
  13.         System.out.println(list);
  15.     }
  17.     //演示JDBC工具类
  18.     //@return
  19.     public List<account> findAll2() {
  20.         ResultSet re = null;
  21.         Statement stmt = null;
  22.         Connection conn = null;
  23.         List<account> list = null;
  24.         try {
  25. //            //1.注册驱动
  26. //            Class.forName("com.mysql.cj.jdbc.Driver");
  27. //            //2.获取链接
  28. //            conn = DriverManager.getConnection("jdbc:mysql:///myfirsttest?serverTimezone=Asia/Shanghai","root","123456");
  29.             conn = JDBCUtils.getConnection();
  30.             //3.定义sql
  31.             String sql = "select * from account";
  32.             //4.获取执行sql的对象
  33.             stmt = conn.createStatement();
  34.             //5.执行sql
  35.             re = stmt.executeQuery(sql);
  36.             //6.遍历结果集，封装对象，装载集合
  37.             account ac = null;
  38.             list = new ArrayList<account>();
  39.             while (re.next()) {
  40.                 //获取数据
  41.                 int id = re.getInt("id");
  42.                 String name = re.getString("name");
  43.                 double balance = re.getDouble("balance");
  44.                 //创建account对象
  45.                 ac = new account();
  46.                 ac.setId(id);
  47.                 ac.setBalance(balance);
  48.                 ac.setName(name);
  49.                 //装载集合
  50.                 list.add(ac);
  51.             }
  53.             //list.forEach(System.out::println);
  55.         }  catch (SQLException e) {
  56.             e.printStackTrace();
  57.         }finally {
  58. //            if (re != null){
  59. //                try {
  60. //                    re.close();
  61. //                } catch (SQLException e) {
  62. //                    e.printStackTrace();
  63. //                }
  64. //            }
  65. //            if (stmt != null){
  66. //                try {
  67. //                    stmt.close();
  68. //                } catch (SQLException e) {
  69. //                    e.printStackTrace();
  70. //                }
  71. //            }
  72. //            if (conn != null){
  73. //                try {
  74. //                    conn.close();
  75. //                } catch (SQLException e) {
  76. //                    e.printStackTrace();
  77. //                }
  78. //            }
  79. //        }
  80.             JDBCUtils.close(re, stmt, conn);
  81.             return list;
  82.         }
  83.     }
  84. }

🍕练习

需求：

  1. 通过键盘录入用户名和密码
  2. 判断用户是否登录成功

select * from user where username = "" and password = "" ;
如果这个sql语句有查询结果，则成功。否则失败。

步骤：

  1. 创建数据表 user

image.pngimage.png

  1. package cn.itcast.jdbc;
  3. import cn.itcast.util.JDBCUtils;
  4. import com.sun.org.apache.bcel.internal.generic.Select;
  6. import java.sql.Connection;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.sql.Statement;
  10. import java.util.Scanner;
  12. /**
  13.  * 需求：
  14.  * 1. 通过键盘录入用户名和密码
  15.  * 2. 判断用户是否登录成功
  16.  */
  17. public class JDBCDemo9 {
  18.     public static void main(String[] args) {
  19.         //1.键盘录入，接受用户名和密码
  20.         Scanner sc = new Scanner(System.in);
  21.         System.out.println("username:");
  22.         String username = sc.nextLine();
  23.         System.out.println("password:");
  24.         String password = sc.nextLine();
  25.         //2.调用方法
  26.         boolean flag = new JDBCDemo9().login(username,password);
  27.         //3.判断结果，输出不同语句
  28.         if (flag){
  29.             //登陆成功
  30.             System.out.println("登陆成功！");
  31.         }else {
  32.             System.out.println("用户名或密码错误！");
  33.         }
  34.     }
  36.     /**
  37.      * 登陆方法
  38.      */
  39.     public boolean login(String username,String password){
  40.         if (username == null || password == null){
  41.             return false;
  42.         }
  43.         //连接数据库判断是否登录成功
  44.         Connection conn = null;
  45.         Statement stmt= null;
  46.         ResultSet re= null;
  47.         //1.获取连接
  48.         try {
  49.             conn = JDBCUtils.getConnection();
  50.             //2.定义sql
  51.             String sql = "select * from user where username = '"+username+"' and password = '"+password+"'";
  52.             //3.获取执行sql对象
  53.             stmt = conn.createStatement();
  54.             //执行查询
  55.             re = stmt.executeQuery(sql);
  56.             //5.判断
  57.             return re.next();//如果有下一行，返回true
  58.         } catch (SQLException e) {
  59.             e.printStackTrace();
  60.         }finally {
  61.             JDBCUtils.close(re,stmt,conn);
  62.         }
  63.         return false;
  64.     }
  65. }

sql注入问题：、

在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性的问题。
🌰随便输入username，然后输入password：a’ or ‘a’ = ‘a ，却登陆成功
image.png

如何解决？

使用 PreparedStatement 对象来解决
预编译的sql：参数使用 ? 作为占位符
步骤：

  1. 导入驱动jar包
  2. 注册驱动
  3. 获取数据库的链接对象 Connection
  4. 定义sql
    • 注意：sql参数使用？作为占位符
      • 🌰： select * from user where username = ? and password = ? ;
  5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
  6. 给“？”赋值
    • 方法：`setXxx(参数1 , 参数2)
      • 参数1：？的位置编号 从1开始
      • 参数2：？的值
  7. 执行sql ， 接收返回结果
  8. 处理结果

  9. 释放资源

    🧐tip

    后期都会使用PreparedStatement来完成增删改查的所有操作
    它可以防止sql注入问题
    效率更高

    事务

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

    操作

  10. 开启事务

  11. 提交事务
  12. 回滚事务

    使用Connection

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

import cn.itcast.util.JDBCUtils; import com.mysql.cj.x.protobuf.MysqlxCrud;

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

/**

  • 事务操作 */ public class JDBCDemo10 { public static void main(String[] args) {

    1.  Connection conn = null;
    2.  PreparedStatement pstm1 = null;
    3.  PreparedStatement pstm2 = null;
    4.  try {
    5.      //1.获取连接
    6.      conn = JDBCUtils.getConnection();
    7.      //开启事务
    8.      conn.setAutoCommit(false);
    10.      //2.定义sql
    11.      //2.1 张三 -500
    12.      String sql1 = "update account set balance = balance - ? where id = ?";
    13.      //2.2 李四 +500
    14.      String sql2 = "update account set balance = balance + ? where id = ?";
    15.      //3.获取执行sql对象
    16.      pstm1 = conn.prepareStatement(sql1);
    17.      pstm2 = conn.prepareStatement(sql2);
    18.      //4.设置参数
    19.      pstm1.setDouble(1,500);
    20.      pstm1.setInt(2,1);
    22.      pstm2.setDouble(1,500);
    23.      pstm2.setInt(2,2);
    24.      //5.执行sql
  1.         // 手动制造异常
  2.         int i = 3/0;
  3.         pstm1.executeUpdate();
  4.         pstm2.executeUpdate();
  6.         //提交事务
  7.         conn.commit();
  8.     } catch (Exception e) {  //事务回滚时候抓大一点的异常
  9.         //事务回滚
  10.         try {
  11.             if (conn!=null){   //conn有可能为null
  12.                 conn.rollback();
  13.             }
  15.         } catch (SQLException ex) {
  16.             ex.printStackTrace();
  17.         }
  18.         e.printStackTrace();
  19.     }finally {
  20.         JDBCUtils.close(pstm1,conn);
  21.         JDBCUtils.close(pstm2,null);
  22.     }
  23. }

}

``` account表没有变化