1、本质

JDBC本质.jpg
JDBC==>Java DataBase Connectivity（Java语言连接数据库）

JDBC的本质是什么？
JDBC是SUN公司制定的一套接口（interface）
java.sql.*; (这个软件包下有很多接口。)

思考：为什么SUN制定一套JDBC接口呢？
因为每一个数据库的底层实现原理都不一样。
Oracle数据库有自己的原理。
MySQL数据库也有自己的原理。
MS SqlServer数据库也有自己的原理。
….
每一个数据库产品都有自己独特的实现原理。

image.png

2、环境配置

JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。

  1. classpath=.;D:\course\06-JDBC\resources\MySql Connector Java 5.1.23\mysql-connector-java-5.1.23-bin.jar
  3. 以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量。<br />    IDEA有自己的配置方式。<br />    ![image.png](https://cdn.nlark.com/yuque/0/2021/png/21675987/1631585050582-1bcbcc86-5cb1-4d6f-a510-17082cf692e1.png#clientId=u88608004-3252-4&from=paste&height=340&id=ud73912cc&margin=%5Bobject%20Object%5D&name=image.png&originHeight=679&originWidth=591&originalType=binary&ratio=1&size=61137&status=done&style=none&taskId=u32fc9692-0451-48ea-b8bb-e9245eab7c0&width=295.5)<br />5中（使用IDEA开发JDBC代码配置驱动）会教我们引入JDBC

3、JDBC编程六步（需要背会）

  • 注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）
  • 获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道。）
  • 获取数据库操作对象（专门执行sql语句的对象）
  • 执行SQL语句（DQL DML….）,JDBC的SQL语句不可以写分号，否则报错
  • 处理查询结果集（只有当第四步执行的是select语句即DQL的时候，才有这第五步处理查询结果集。）

  • 释放资源（使用完资源之后一定要关闭资源。Java和数据库属于进程间的通信，开启之后一定要关闭。）

    1）连接方式一

    实际操作一下吧,以下是文本方式，不是IDEA

    1. //JDBC编程
    2. import java.sql.Driver;
    3. import java.sql.DriverManager;
    4. import java.sql.SQLException;
    5. import java.sql.Connection; 
    6. import java.sql.Statement;
    7. public class JDBCTest01{
    8.   public static void main(String []args){
    9.       Statement stmt =null;
    10.       Connection conn =null;
    12.       try{
    13.       //注册驱动
    14.           Driver driver = new com.mysql.jdbc.Driver();//多态，父类型引用指向子类型对象
    15.           //Driver drtiver =new oracle.jdbc.driver.OracleDriver();//oracle驱动   
    16.           DriverManager.registerDriver(driver);
    17.       //2、获取连接
    18.           /*
    20.           */
    21.           String url ="jdbc:mysql:/127.0.0.1:3306/node";
    22.           String user="root";
    23.           String password ="";
    24.           conn = DriverManager.getConnection(url,user,password);
    25.           System.out.println("数据库连接对象="+conn);
    27.       //3、获取数据库操作对象（专门执行sql语句的对象）
    28.          stmt = conn.createStatement();
    30.       //4、执行SQL
    31.           String sql ="insert into dept(deptno,dename,loc) values(50,'人事部','北京')";
    32.           //专门执行DML语句（insert delete update）
    33.           //返回值是影响数据库中记录条数
    34.           int count=stmt.executeUpdate(sql);//执行DML语句
    35.           System.out.println(count==1?"保存成功"："保存失败");
    37.           //5、处理查询结果集
    39.       }catch(SQLException e){
    40.           e.printStackTrace();
    41.       }finally{
    42.           //6、释放资源
    43.           //为了保证资源一定释放，在finally语句块中关闭资源
    44.           //并且要遵守从小到大一次关闭
    45.           //分别对其try..catch
    46.           if(stmt != null){
    47.               try{
    48.                   stmt.close();
    49.               } catch(SQLException e){
    50.               e.printStackTrace();
    51.           }
    52.           }
    54.           if(conn != null){
    55.            try{
    56.                   stmt.close();
    57.               }catch(SQLException e){
    58.               e.printStackTrace();
    59.           }
    60.           } 
    61.       }
    62.   }
    63. }

    练习2：删除

    1. //JDBC编程
    2. import java.sql.*;
    3. public class JDBCTest02{
    4.   public static void main(String []args){
    5.       Statement stmt =null;
    6.       Connection conn =null;
    8.       try{
    9.       //1、注册驱动 
    10.          DriverManager.registerDriver(new com.mysql.jdbc.Driver());
    12.       //2、获取连接
    13.          conn = DriverManager.getConnection("jdbc:mysql:/127.0.0.1:3306/node","root",""); 
    15.       //3、获取数据库操作对象（专门执行sql语句的对象）
    16.          stmt = conn.createStatement();   
    18.       //4、执行SQL,
    19.         // String sql ="delete from dept where deptno =40";
    20.           String sql ="updata dept set dname = '销售部'，loc='天津'where deptno=20";
    21.           //专门执行DML语句（insert delete update）
    22.           //返回值是影响数据库中记录条数
    23.           int count=stmt.executeUpdate(sql);//执行DML语句
    24.           System.out.println(count==1?"删除成功"："删除失败");
    26.           //5、处理查询结果集
    28.       }catch(SQLException e){
    29.           e.printStackTrace();
    30.       }finally{
    31.           //6、释放资源
    32.           //为了保证资源一定释放，在finally语句块中关闭资源
    33.           //并且要遵守从小到大一次关闭
    34.           //分别对其try..catch
    35.        if(stmt != null){
    36.               try{
    37.                   stmt.close();
    38.               } catch(SQLException e){
    39.               e.printStackTrace();
    40.           }
    41.           }
    43.           if(conn != null){
    44.            try{
    45.                   stmt.close();
    46.               }catch(SQLException e){
    47.               e.printStackTrace();
    48.           }
    49.           } 
    51.       }
    52.   }
    53. }

    2）连接方式二：类加载方式注册驱动(常使用)

    1. //JDBC编程
    2. import java.sql.*;
    3. public class JDBCTest03{
    4.   public static void main(String []args){   
    5.       try{
    6.       //1、注册驱动 
    7.        ////注册驱动第一种方法
    8.         // DriverManager.registerDriver(new com.mysql.jdbc.Driver());
    10.         //注册驱动第二种方法
    11.         //以下方法不需要接收返回值，因为我们只想用它的类加载动作
    12.          //这个类有一个静态方法，执行了注册驱动方法一，而类加载动作会执行静态方法
    13.         Class.forName("com.mysql.jdbc.Driver");
    14.       //2、获取连接
    15.        Connection  conn = DriverManager.getConnection("jdbc:mysql:/127.0.0.1:3306/node","root",""); 
    16.       }catch(SQLException e){
    17.           e.printStackTrace();
    18.       }
    19.   }
    20. }

    3）连接方式三：从属性文件中读取连接数据库信息

    不建议写死在Java程序中；

    1. //JDBC编程
    2. import java.sql.*;
    3. public class JDBCTest04{
    4.   public static void main(String []args){
    5.       //使用资源绑定器绑定属性配置文件
    6.       ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
    7.       String driver = bundle.getString("driverClass");
    8.       String url  = bundle.getString("url");
    9.       String user = bundle.getString("user");
    10.       String password = bundle.getString("password");
    11.       Statement stmt =null;
    12.       Connection conn =null;
    14.       try{
    15.       //注册驱动
    16.         Class.forName(driver);
    18.       //2、获取连接
    19.           conn = DriverManager.getConnection(url,user,password);
    21.       //3、获取数据库操作对象（专门执行sql语句的对象）
    22.          stmt = conn.createStatement();
    24.       //4、执行SQL
    25.           String sql ="insert into dept(deptno,dename,loc) values(50,'人事部','北京')";
    26.           //专门执行DML语句（insert delete update）
    27.           //返回值是影响数据库中记录条数
    28.           int count=stmt.executeUpdate(sql);//执行DML语句
    29.           System.out.println(count==1?"保存成功"："保存失败");
    31.           //5、处理查询结果集
    33.       }catch(Exception e){
    34.           e.printStackTrace();
    35.       }finally{
    36.           //6、释放资源
    37.           //为了保证资源一定释放，在finally语句块中关闭资源
    38.           //并且要遵守从小到大一次关闭
    39.           //分别对其try..catch
    40.          if(stmt != null){
    41.               try{
    42.                   stmt.close();
    43.               } catch(SQLException e){
    44.               e.printStackTrace();
    45.           }
    46.           }
    48.           if(conn != null){
    49.            try{
    50.                   stmt.close();
    51.               }catch(SQLException e){
    52.               e.printStackTrace();
    53.           }
    54.           } 
    56.       }
    57.   }
    58. }
    1. //jdbc.properties
    2. user=root
    3. password=abc123
    4. url=jdbc:mysql://localhost:3306/test
    5. driverClass=com.mysql.jdbc.Driver

    4、处理查询结果集

    遍历结果集.jpg

    1. //JDBC编程
    2. import java.sql.*;
    3. public class JDBCTest05{
    4.   public static void main(String []args){
    5.       Statement stmt =null;
    6.       Connection conn =null;
    7.       ResultSet rs =null;
    8.       try{
    9.       //1、注册驱动 
    10.          Class.forName("com.mysql.jdbc.Driver");   
    11.       //2、获取连接
    12.          conn = DriverManager.getConnection("jdbc:mysql:/127.0.0.1:3306/node","root",""); 
    14.       //3、获取数据库操作对象（专门执行sql语句的对象）
    15.          stmt = conn.createStatement();   
    17.       //4、执行SQL,
    18.        String sql ="select empno as a,ename,sal from emp";
    20.        //返回int executeUpdata(insert/delete/updata)
    21.       // 返回结果集ResultSet executeQuery(select)
    22.       re =stmt.executeQuery(sql);
    24.      //5、处理查询结果集
    25.      //光标指向的行有数据
    26.      //取数据
    27.      //getString() ：不管数据库的数据类型是神，都以String的形式取出
    28.     // boolean flag1 =rs.next();
    29.      while(rs.next()){
    30.   //列的下表
    31.   //       String enpno = rs.getString(1);
    32.    //   String ename = rs.getString(2);
    33.    //   String sal = rs.getString(3);
    35.     //以列的名称获取
    36.       //String enpno = rs.getString("enpno");
    37.       int enpno = rs.getInt("a");//列名称不是表中的列，是查询结果集的列名称
    38.       String ename = rs.getString("ename");
    39.       double sal = rs.getDouble("sal");
    40.       System.out.println(empno+","+ename+","+sal);
    41.      }
    42.       }catch(Exception e){
    43.           e.printStackTrace();
    44.       }finally{
    45.           //6、释放资源
    46.           //为了保证资源一定释放，在finally语句块中关闭资源
    47.           //并且要遵守从小到大一次关闭
    48.           //分别对其try..catch
    49.               //分别对其try..catch
    50.        if(rs != null){
    51.               try{
    52.                   rs.close();
    53.               } catch(SQLException e){
    54.               e.printStackTrace();
    55.           }
    56.         }
    57.        if(stmt != null){
    58.               try{
    59.                   stmt.close();
    60.               } catch(SQLException e){
    61.               e.printStackTrace();
    62.           }
    63.         }
    65.           if(conn != null){
    66.            try{
    67.                   stmt.close();
    68.               }catch(SQLException e){
    69.               e.printStackTrace();
    70.           }
    71.           } 
    73.       }
    74.   }
    75. }

    5、使用IDEA开发JDBC代码配置驱动

    首先建立一个新工程
    image.pngimage.png
    建立一个模块jdbc_test,然后添加驱动jar包
    image.png
    选择Libraries—>’+’选择Java—>找到驱动jar包
    image.png
    引入成功
    image.png

    6、PowerDesigner

    在实际开发中，表的设计会使用专业的建模工具，我们这里安装一个建模工具：PowerDesigner用于数据的准备
    image.png
    选择HongKong（为了破解）
    image.png
    C盘太满，选择了F盘，然后一直下一步就行了
    image.png
    点击Finish，就可以啦
    image.png
    2、将pdflm16.dll拷贝到安装目录进行覆盖
    image.png

image.png
image.png
image.png
构建用户表（t_user）
image.png
image.png
点击确定后，在双击打开，Preview中有了SQL语句，点击保存按钮可以保存sql文件
image.png
然后我把这个sql导入
image.png

7、SQL注入

image.png

  1. package com.fawdezjb.jdbc;
  3. import java.sql.*;
  4. import java.util.*;
  6. /*
  7. * 模拟用户登录功能
  8. * 2、业务描述
  9. * 程序运行时，提供一个输入的入口，可以让用户输入用户名和密码
  10. * 用户输入后，提交信息，Java程序收集用户信息
  11. * Java程序验证用户信息是否合法
  12. * 合法：显示登录成功
  13. * 不合法: 显示登录失败
  14. * 3、数据的准备
  15. * 在实际开发中，表的设计会使用专业的建模工具，我们这里安装一个建模工具：PowerDesigner
  16. * 用PD工具来进行数据库表的设计
  17. * 4、当前程序存在问题
  18. *   用户名：fdsa
  19. *   密码： fasa'or'1'='1
  20. *   登录成功
  21. *   这种现象被称为SQL注入(安全隐患)。(黑客经常使用)
  22. * 5、导入SQL注入的根本原因是什么？
  23. * 用户输入的信息中含有sql语句的关键词，并且这些关键词参与了sql语句的编译过程
  24. * 导致了原sql语句的含义被扭曲，进而达到sql注入。
  25. * 6、
  26. * */
  27. public class JDBCTest06 {
  28.     public static void main(String[] args) {
  29.         //初始化一个界面
  30.         Map<String,String> userLoginInfo =initUI();
  31.         //验证用户名和密码
  32.        boolean loginSuccess= login(userLoginInfo);
  33.         System.out.println(loginSuccess?"登录成功":"登录失败");
  34.     }
  35. /*
  36. * 用户登录
  37. * @param userLoginInfo用户登录信息
  38. * @return false 表示失败
  39. * */
  40.     private static boolean login(Map<String, String> userLoginInfo) {
  41.         //
  42.         boolean flag = false;
  43.         String loginName= userLoginInfo.get("loginName");
  44.         String loginPwd = userLoginInfo.get("loginpwd");
  45.         //JDBC代码
  46.         Connection con =null;
  47.         Statement stmt =null;
  48.         ResultSet rs =null;
  50.         try {
  51.             //1、注册驱动
  52.             Class.forName("com.mysql.jdbc.Driver");
  53.             //2、获取连接
  54.             con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/sqlearn","root","");
  55.             //3、获取数据库操作对象
  56.             stmt = con.createStatement();
  57.             //4、执行sql
  58.             String sql = "select * from t_user where loginName='"+loginName+"' and loginPwd='"+loginPwd+"'";
  59.             //以上正好完成了sql语句的拼接，以下代码的含义是，是发送sql语句给DBMS，DBMS进行sql编译
  60.             //正好将用户提供的“非法信息”编译进去，导致了原sql语句的含义被扭曲了
  61.             rs = stmt.executeQuery(sql);
  62.             //5、处理结果集
  63.             if(rs.next()){
  64.                 //
  65.                 flag = true;
  66.             }
  67.         } catch (Exception e) {
  68.             e.printStackTrace();
  69.         }finally {
  70.             //6、释放资源
  71.             if(rs!=null){
  72.                 try {
  73.                     rs.close();
  74.                 } catch (SQLException throwables) {
  75.                     throwables.printStackTrace();
  76.                 }
  77.             }
  79.             if(stmt!=null){
  80.                 try {
  81.                     stmt.close();
  82.                 } catch (SQLException throwables) {
  83.                     throwables.printStackTrace();
  84.                 }
  85.             }
  86.             if(con!=null){
  87.                 try {
  88.                     con.close();
  89.                 } catch (SQLException throwables) {
  90.                     throwables.printStackTrace();
  91.                 }
  92.             }
  93.         }
  94.         return  flag;
  95.     }
  97.     /*
  98. * 初始化用户界面
  99. * @return用户输入的用户名和密码
  100. * */
  101.     private static Map<String,String> initUI() {
  102.         Scanner s =new Scanner(System.in);
  103.         System.out.println("用户名：");
  104.         String username=s.nextLine();
  105.         System.out.println("密码：");
  106.         String password =s.nextLine();
  107.         Map<String,String> userLoginInfo = new HashMap<>();
  108.         userLoginInfo.put("loginName",username);
  109.         userLoginInfo.put("loginpwd",password);
  110.         return  userLoginInfo;
  111.     }
  114. }

8、PrepareStatement

  1. package com.fawdezjb.jdbc;
  3. import java.sql.*;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Scanner;
  7. /*
  8. * 1、解决sql注入问题
  9. * 只要用户提供的信息不参与sql语句的编译过程，问题就解决了
  10. * 即使用户提供的信息中含有sql语句的关键字，但是没有参与编译，不起作用
  11. * 要想用户信息不参与SQL语句的编译，那么必须使用java.sql.PrepareStatement
  12. * PrepareStatement接口继承了java.sqk.Statement
  13. * PrepareStatement是属于预编译的数据库操作对象
  14. * PrepareStatement的原理是：预先对SQL语句的框架进行编译，然后再给SQL语句传“值”
  15. *2、测试结果：注入失败
  16. * 3、解决SQL注入的关键是？
  17. * 用户提供的信息中含有sql语句的关键字，但是没有参与编译，不起作用
  18. * 4、对比一下Statement与PrepareStatement?
  19. * -Statement存在SQL注入问题，PrepareStatement解决了SQL注入问题
  20. * -Statement是编译一次执行一次，PrepareStatement是编译一次，可以执行N次。PrepareStatement效率较高一些
  21. * -PrepareStatement会在编译阶段做类型的安全检查
  22. *
  23. * 综上所述：PrepareStatement使用较多，极少情况下需要使用Statement
  24. * 5、什么情况下必须使用Statement呢？
  25. * 业务方面要求必须支持sql注入的时候。
  26. * Statement支持SQL注入，凡是业务方面要求需要进行SQL语句拼接的时候必须使用Statement
  27. * */
  28. public class JDBCTest07 {
  29.     public static void main(String[] args) {
  30.         //初始化一个界面
  31.         Map<String,String> userLoginInfo =initUI();
  32.         //验证用户名和密码
  33.         boolean loginSuccess= login(userLoginInfo);
  34.         System.out.println(loginSuccess?"登录成功":"登录失败");
  35.     }
  36.     /*
  37.      * 用户登录
  38.      * @param userLoginInfo用户登录信息
  39.      * @return false 表示失败
  40.      * */
  41.     private static boolean login(Map<String, String> userLoginInfo) {
  42.         //
  43.         boolean flag = false;
  44.         String loginName= userLoginInfo.get("loginName");
  45.         String loginPwd = userLoginInfo.get("loginpwd");
  46.         //JDBC代码
  47.         Connection con =null;
  48.         PreparedStatement ps =null;//这里使用PreparedStatement(预编译的数据库操作对象)
  49.         ResultSet rs =null;
  51.         try {
  52.             //1、注册驱动
  53.             Class.forName("com.mysql.jdbc.Driver");
  54.             //2、获取连接
  55.             con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/sqlearn","root","");
  56.             //3、获取预编译的数据库操作对象
  57.             //sql语句框架，其中一个？表示一个占位符，一个？将来接收一个“值”，注意：占位符不能用单引号括起来
  58.             String sql = "select * from t_user where loginName = ? and loginPwd = ?";
  59.             ps = con.prepareStatement(sql);
  60.             //给占位符？传值（第一个问号下标是1，第二个问号下标是2，JDBC中所有下标从1开始）
  61.             ps.setString(1,loginName);
  62.             ps.setString(2,loginPwd);
  63.             //4、执行sql
  64.             rs = ps.executeQuery(sql);
  65.             //5、处理结果集
  66.             if(rs.next()){
  67.                 //
  68.                 flag = true;
  69.             }
  70.         } catch (Exception e) {
  71.             e.printStackTrace();
  72.         }finally {
  73.             //6、释放资源
  74.             if(rs!=null){
  75.                 try {
  76.                     rs.close();
  77.                 } catch (SQLException throwables) {
  78.                     throwables.printStackTrace();
  79.                 }
  80.             }
  82.             if(ps!=null){
  83.                 try {
  84.                     ps.close();
  85.                 } catch (SQLException throwables) {
  86.                     throwables.printStackTrace();
  87.                 }
  88.             }
  89.             if(con!=null){
  90.                 try {
  91.                     con.close();
  92.                 } catch (SQLException throwables) {
  93.                     throwables.printStackTrace();
  94.                 }
  95.             }
  96.         }
  97.         return  flag;
  98.     }
  100.     /*
  101.      * 初始化用户界面
  102.      * @return用户输入的用户名和密码
  103.      * */
  104.     private static Map<String,String> initUI() {
  105.         Scanner s =new Scanner(System.in);
  106.         System.out.println("用户名：");
  107.         String username=s.nextLine();
  108.         System.out.println("密码：");
  109.         String password =s.nextLine();
  110.         Map<String,String> userLoginInfo = new HashMap<>();
  111.         userLoginInfo.put("loginName",username);
  112.         userLoginInfo.put("loginpwd",password);
  113.         return  userLoginInfo;
  114.     }
  115. }

9、PreparedStatement完成增删改查

  1. package com.fawdezjb.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.SQLException;
  8. /*
  9. * PreparedStatement完成insert、delete、update
  10. * */
  11. public class JDBCTest09 {
  12.     public static void main(String[] args) {
  13.         Connection conn =null;
  14.         PreparedStatement ps=null;
  15.         try {
  16.             //1、注册驱动
  17.             Class.forName("com.mysql.jdbc.Driver");
  18.             //2、获取连接
  19.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/sqlearn","root","");
  21.             //3、获取预编译的数据库操作对象
  22.             String sql ="update dept set dname =?,loc=? where deptno = ? ";
  23.             ps= conn.prepareStatement(sql);
  24.             ps.setInt(3,60);
  25.             ps.setString(1,"4556");
  26.             ps.setString(2,"shanghai");
  27.             //4、执行SQL
  28.             int count =ps.executeUpdate();
  29.             System.out.println(count);
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         }finally {
  33.             if(ps!=null){
  34.                 try {
  35.                     ps.close();
  36.                 } catch (SQLException throwables) {
  37.                     throwables.printStackTrace();
  38.                 }
  39.             }
  40.             if(conn!=null){
  41.                 try {
  42.                     conn.close();
  43.                 } catch (SQLException throwables) {
  44.                     throwables.printStackTrace();
  45.                 }
  46.             }
  47.         }
  49.     }
  50. }

10、事务

jdbc和MySQL中一样，都是自动提交的

  1. package com.fawdezjb.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.SQLException;
  8. /*
  9. * drop table if exists t_act;
  10. * create table t_act(
  11. * actno int,
  12. * balance double(7,2)
  13. * );
  14. * insert into t_act(actno,balance) values(111,20000);
  15. * insert into t_act(actno,balance) values(222,0);
  16. * commit;
  17. * select * from t_act;
  18. *
  19. * 重点三行代码：
  20. *    //将自动提交机制修改为手动提交
  21.       conn.setAutoCommit(false);
  22.       //手动提交事务
  23.       conn.commit();
  24.      conn.rollback();
  25. * */
  26. public class JDBC10 {
  27.     public static void main(String[] args) {
  28.         Connection conn =null;
  29.         PreparedStatement ps=null;
  30.         try {
  31.             //1、注册驱动
  32.             Class.forName("com.mysql.jdbc.Driver");
  33.             //2、获取连接
  34.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/sqlearn","root","");
  35.             //将自动提交机制修改为手动提交
  36.             conn.setAutoCommit(false);//开启事务
  37.             //3、获取预编译的数据库操作对象
  38.           String sql= "update t_act set balance = ? where actno = ?";
  39.           ps = conn.prepareStatement(sql);
  40.           //
  41.             ps.setDouble(1,10000);
  42.             ps.setInt(2,111);
  43.             int count = ps.executeUpdate();
  45. //            String s =null;
  46. //            s.toString();
  48.             ps.setDouble(1,10000);
  49.             ps.setInt(2,222);
  50.             count += ps.executeUpdate();
  51.             System.out.println(count==2?"转账成功":"转账失败");
  52.             //手动提交事务
  53.             conn.commit();
  55.         } catch (Exception e) {
  56.             //回滚事务
  57.             try {
  58.                 conn.rollback();
  59.             } catch (SQLException throwables) {
  60.                 throwables.printStackTrace();
  61.             }
  62.             e.printStackTrace();
  63.         }finally {
  64.             if(ps!=null){
  65.                 try {
  66.                     ps.close();
  67.                 } catch (SQLException throwables) {
  68.                     throwables.printStackTrace();
  69.                 }
  70.             }
  71.             if(conn!=null){
  72.                 try {
  73.                     conn.close();
  74.                 } catch (SQLException throwables) {
  75.                     throwables.printStackTrace();
  76.                 }
  77.             }
  78.         }
  79.     }
  80. }

11、JDBC工具类的封装

建一个工具包utils
image.png

  1. package com.fawdezjb.jdbc.utils;
  3. import java.sql.*;
  5. /*
  6. * JDBC工具类，简化JDBC编程
  7. * */
  8. public class DButil {
  9.     /*
  10.     * 工具类中的构造方法都是私有的
  11.     * 因为工具类当中的方法都是静态的，不需要new新对象，直接采用类名调用
  12.     * */
  13.     private DButil(){
  15.     }
  16.     //静态代码块在类加载时执行，并且只执行一次
  17.     static {
  18.         try {
  19.             Class.forName("com.mysql.jdbc.Driver");
  20.         } catch (ClassNotFoundException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24.     //获取数据库连接对象
  25.     public static Connection getConnection() throws SQLException {
  26.         return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/sqlearn","root","");
  27.     }
  28.     //关闭资源
  29.     //这个为啥不抛，因为最后运行，再抛出去无后续代码处理
  30.     public static void close(Connection conn, Statement ps, ResultSet rs){
  31.         if(rs!=null){
  32.             try {
  33.                 rs.close();
  34.             } catch (SQLException throwables) {
  35.                 throwables.printStackTrace();
  36.             }
  37.         }
  39.         if(ps!=null){
  40.             try {
  41.                 ps.close();
  42.             } catch (SQLException throwables) {
  43.                 throwables.printStackTrace();
  44.             }
  45.         }
  46.         if(conn!=null){
  47.             try {
  48.                 conn.close();
  49.             } catch (SQLException throwables) {
  50.                 throwables.printStackTrace();
  51.             }
  52.         }
  53.     }
  54. }

行级锁（悲观锁）

image.png
select * from student where id =101 for update;//上锁了