网友整理老杜2020版本JDBC:
https://blog.csdn.net/qq_32480989/article/details/120876779

JDBC 基础概念

  1. JDBC是什么？

    Java DataBase Connectivity（ Java语言连接数据库）

  2. JDBC的本质是什么？

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

    接口都有调用者和实现者。
    面向接口调用、面向接口写实现类，这都属于面向接口编程。

  3. 为什么要面向接口编程？

    1.  **解耦合：降低程序的耦合度，提高程序的扩展力。**<br />        多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）<br />            建议：        
    1.  Animal a = new Cat();
    2.  Animal a = new Dog();
    3.  // 喂养的方法
    4.  public void feed(Animal a){ // 面向父类型编程。
    6.  }
    7.  不建议：
    8.  Dog d = new Dog();
    9.                  Cat c = new Cat();

  1. 思考：为什么SUN制定一套JDBC接口呢？

    1.  因为每一个数据库的底层实现原理都不一样,Oracle数据库有自己的原理,MySQL数据库也有自己的原理,每一个数据库产品都有自己独特的实现原理。<br />

  2. JDBC的本质到底是什么？

    1.  **一套接口**

    JDBC 开发流程

    开发流程

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

    1. classpath=.;D:\course\06-JDBC\resources\MySql Connector Java 5.1.23\mysql-connector-java-5.1.23-bin.jar

    注意：

    • .；表示任意路径
    • 以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量
    • IDEA有自己的配置方式。

  1. JDBC编程六步（需要背会）


    第一步：注册驱动（作用：告诉Java程序，即将要连接的是哪个品牌的数据库）

    第二步：获取连接（表示JVM的进程和数据库进程之间的通道打开了，这属于进程之间的通信，重量级的，使用完之后一定要关闭通道。）

    第三步：获取数据库操作对象（专门执行sql语句的对象）

    第四步：执行SQL语句（DQL DML….）

    第五步：处理查询结果集（只有当第四步执行的是select语句的时候，才有这第五步处理查询结果集。）

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

模拟JDBC的本质

image.png
image.png

image.pngimage.png

  1. JDBC的本质

JDBC本质.jpg

JDBC 课堂测试源码

  1. java.SQL包下：
  • java 中 sql 源码路径：

java帮助文档——>java.SQL包下———->类、接口
复习：除了java.lang包，其余包都需要导包

  1. JDBC开发的步骤详细说明：
  • 第一步：注册驱动

有一个类 ：DriverManager 驱动管理器 Driver 的意思是驱动
里面有一个方法：static void registerDriver( Driver driver) 注册驱动的方法
这个方法的参数的说明：Driver是一个接口 无法new对象，就得找Driver的实现类，这个实现类是有数据库厂商写的，得去new产商写的那个实现类Driver
格式：new 包名.类名（）；
说明：厂商的实现类是公开的，需要包名.方式去访问这个实现类，然后再创建这个类的对象，去厂商的jar包找这个实现类。

  1. 这个方法的异常说明：

image.png
说明：继承了 exception 说明了 是受检异常，需要处理，

  • 第二步：获取连接

url：统一资源定位符（网络中某个资源的绝对路径）
https://www.baidu.com/ 这就是URL。
URL包括哪几部分？
协议
IP
PORT
资源名

  1.             [http://182.61.200.7:80/index.html](http://182.61.200.7:80/index.html)<br />                    http:// 通信协议<br />                    182.61.200.7 服务器IP地址<br />                    80 服务器上软件的端口<br />                    index.html 是服务器上某个资源名<br />                <br />                <br />                **jdbc:mysql://127.0.0.1:3306/bjpowernode**<br />                    jdbc:mysql:// 协议<br />                    127.0.0.1 IP地址<br />                    3306 mysql数据库端口号<br />                    bjpowernode 具体的数据库实例名。<br />                <br />                说明：localhost和127.0.0.1都是本机IP地址。
  3.             jdbc:mysql://192.168.151.27:3306/bjpowernode<br />

  • 什么是通信协议，有什么用？

    1.               通信协议是通信之前就提前定好的数据传送格式。<br />                    数据包具体怎么传数据，格式提前定好的。<br />

  • oracle的URL：

    1.               jdbc:oracle:thin:@localhost:1521:orcl
  1. JDBCTest01源码

编程六步：

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

  1. JDBC完成 delete、updata

    学习方法：下去背代码
    JDBCtest02

注册驱动的另一种方式

  1. JDBCTest03 ```java import java.sql.*;

public class JDBCTest03{ public static void main(String[] args){ try{ //1、注册驱动 // 这是注册驱动的第一种写法。 // DriverManager.registerDriver(new com.mysql.jdbc.Driver()); // 注册驱动的第二种方式：常用的。 // 为什么这种方式常用？因为参数是一个字符串，字符串可以写到xxx.properties文件中。 // 以下方法不需要接收返回值，因为我们只想用它的类加载动作。 Class.forName(“com.mysql.jdbc.Driver”); //反射机制进行类加载 //Class.forName()方法的执行会导致，方法里面的类进行类加载，然后静态代码块执行，完成驱动的注册 //2、获取连接 Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/bjpowernode”,”root”,”333”); // com.mysql.jdbc.JDBC4Connection@41cf53f9 System.out.println(conn);

  1.     }catch(SQLException e){
  2.         e.printStackTrace();
  3.     }catch(ClassNotFoundException e){
  4.         e.printStackTrace();
  5.     }
  6. }

}

  2. **将连接数据库的所有信息配置到配置文件当中**
  3. <a name="x5Voq"></a>
  4. ## 从属性资源文件中读取连接数据库信息
  5. Test04
  6. ```java
  7. driver=com.mysql.cj.jdbc.Driver
  8. url=jdbc:mysql://127.0.0.1:3306/bjpowernode
  9. user=root
  10. password=123456

配置文件：jdbc.properties

  1. package jdbc;
  3. import java.sql.*;
  4. import java.util.ResourceBundle;
  5. /*
  6. 实际开发中不建议把连接数据库的信息写死在java程序中。
  7.  */
  8. public class jdbc04 {
  9.     public static void main(String[] args) {
  10.         // 使用资源绑定器绑定属性配置文件
  11.         ResourceBundle bundle =ResourceBundle.getBundle("jdbcc");
  12.         String driver=bundle.getString("key");
  13.         String url=bundle.getString("url");
  14.         String user=bundle.getString("user");
  15.         String password=bundle.getString("password");
  17.         Connection conn=null;
  18.         Statement stmt=null;
  19.         try {
  20.             //1、注册驱动(只需要改这个)
  21.             Class.forName(driver);
  22.             //2、获取连接
  23.             conn = DriverManager.getConnection(url,user,password);
  24.             //3、获取数据库操作对象
  25.             stmt=conn.createStatement();//
  26.             //4、执行sql
  27.             String sql="update dept set dname='销售部2',loc='天津'where deptno=20";
  28.             int count=stmt.executeUpdate(sql);
  29.             System.out.println(count==1?"修改成功":"修改失败");
  31.         } catch (SQLException e) {
  32.             e.printStackTrace();
  33.         }catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         }finally{
  36.             //6、释放资源
  37.             if(stmt!=null){
  38.                 try{
  39.                     stmt.close();
  40.                 }catch(SQLException e){
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.             if(conn!=null){
  45.                 try{
  46.                     conn.close();
  47.                 }catch(SQLException e){
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }

处理查询结果集

笔记： 查询完的结果封装在 ResultSet里面
Test05

  1. package jdbc;
  3. import javax.swing.*;
  4. import java.sql.*;
  5. /*
  6. 处理查询结果集
  7. */
  8. public class jdbc05 {
  9.     public static void main(String[] args) {
  10.         Connection conn=null;
  11.         Statement stmt=null;
  12.         ResultSet rs=null;
  13.         try {
  14.             //1、注册驱动
  15.             DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
  16.             //2、获取连接
  17.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode","root","123456");
  18.             //3、获取数据库操作对象
  19.             stmt=conn.createStatement();//
  20.             //4、执行sql
  21.             String sql="select empno,ename,sal from emp";
  22.             //ResultSet executeQuery(String sql) throws SQLEXception
  23.             //执行给定的SQL语句，该语句返回单词ResultSet对象。
  24.             // 参数sql 为要发送给数据库的SQL语句，通常为静态SQL select语句。
  25.             //int executeUpdate(insert/delete/update)
  26.             //ResultSet executeQuery(select)//ResultSet是执行sql语句后的查询结果集
  27.             rs=stmt.executeQuery(sql);
  28.             //5、处理查询结构集
  29. /*理解过程
  30.             boolean flag1=rs.next();//本来在第0行，现在next到了第一行，如果有数据就返回true
  31.             // System.out.println(flag1); //true
  32.             if(flag1){
  33.                 //光标指向的行有数据
  34.                 //取数据
  35.                 //getString()方法的特点是：不管数据库中的数据类型是什么，都以String的形式取出
  36.                 String empno=rs.getString(1);//跟的是下标，第一列，第二列，第三列
  37.                 String ename=rs.getString(2);//jdbc中所有的下标从1开始，不是从0开始的
  38.                 String sal=rs.getString(3);
  39.                 System.out.println(empno+","+ename+","+sal);
  40.             }
  42.             //rs.next();
  43.             //boolean next() throws SQLException将光标从当前位置向前移一行。
  44.             // ResultSet 光标最初位于第一行之前；第一次调用 next
  45.             // 方法使第一行成为当前行；第二次调用使第二行成为当前行，依此类推。
  46.             // 返回：如果新的当前行有效，则返回 true；如果不存在下一行，则返回 false
  47.             //抛出：SQLException - 如果发生数据库访问错误或在关闭的结果集上调用此方法
  48. */
  49.           while(rs.next()){
  50.               /*
  51.               String empno=rs.getString(1);
  52.               String ename=rs.getString(2);
  53.               String sal=rs.getString(3);
  54.               System.out.println(empno+","+ename+","+sal);
  55.               */
  57.               /*另一种写法，不是以列的下标获取，以列的名字获取
  58.               String empno=rs.getString("empno");
  59.               String ename=rs.getString("ename");
  60.               String sal=rs.getString("sal");
  61.               System.out.println(empno+","+ename+","+sal);
  62.               */
  64.               int empno=rs.getInt(1);//之所以这能用int 是因为底层数据是int类型的，不然要以String类型
  65.               String ename=rs.getString(2);
  66.               double sal=rs.getDouble(3);
  67.               System.out.println(empno+","+ename+","+(sal-100));//double类型 方便进行运算
  69.           }
  72.         } catch (SQLException e) {
  73.             e.printStackTrace();
  74.         }finally{
  75.             //6、释放资源
  76.             if(rs!=null){//释放查询结果集
  77.                 try{
  78.                     rs.close();
  79.                 }catch(SQLException e){
  80.                     e.printStackTrace();
  81.                 }
  82.             }
  83.             if(stmt!=null){//释放数据库操作对象
  84.                 try{
  85.                     stmt.close();
  86.                 }catch(SQLException e){
  87.                     e.printStackTrace();
  88.                 }
  89.             }
  90.             if(conn!=null){//释放数据库连接对象
  91.                 try{
  92.                     conn.close();
  93.                 }catch(SQLException e){
  94.                     e.printStackTrace();
  95.                 }
  96.             }
  97.         }
  98.     }
  99. }

ResultSet rs 存的是执行sql语句后的查询结果集
遍历结果集：
遍历结果集.jpg

IDEA工具开发JDBC

将JDBC的jar包导入idea步骤

  • 第一种方式：
    • 打开模块设置

image.png

  • 鼠标点的这个英文单词为库

image.png

  • 添加Java库，选择 JDBC.jar 包路径 导入

说明：如果建立新的模块需要将，jar包重新导入

第二种方式：

  • 在需要导入的模块，建立目录，然后将JDBC的jar包粘贴到此目录

  • 第二步：将jar包，加入到这个模块就行

image.png

快捷键

  • ctrl +shift+F12
  • ifn

idea中第一个JDBC程序

数据库表的设计阶段

  1. PowerDesigner 数据库表设计 工具的安装

作用：物理建模的，系统设计时用 PowerDesigner 工具
image.png

  • 将激活文件到安装目录进行，替换
  1. 使用步骤：

image.png
快捷键：按住ctrl键+鼠标滑轮，就可以看见很多单元格

双击新建的表，在新的窗口进行设计
image.png

小项目

需求：模拟用户登录功能的实现
描述：

开发经验：能抽象成一个方法的最好抽象成一个方法

SQL注入问题

JDBCTest06 存在SQL注入问题

  1. package jdbc;
  3. import java.sql.*;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Scanner;
  8. public class jdbc06 {
  9.     public static void main(String[] args) {
  10.         //初始化一个界面，可以让用户输入用户名和密码
  11.       Map<String,String>userLoginInfo=initUI();
  12.         //连接数据库验证用户和密码是否正确
  13.       boolean ok=checkNameAndPwd(userLoginInfo.get("loginName"),userLoginInfo.get("loginPwd"));
  14.         System.out.println(ok?"登陆成功":"登陆失败");
  16.     }
  18.     private static boolean checkNameAndPwd(String loginName, String loginPwd) {
  19.          boolean ok=false;//默认登录是失败的，
  20.         Connection conn = null;
  21.         Statement stmt = null;
  22.         ResultSet rs = null;
  24.             // 1、注册驱动
  25.             try {
  26.                 Class.forName("com.mysql.cj.jdbc.Driver");
  27.                 // 2、获取连接
  28.                 conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  29.                 // 3、获取数据库操作对象
  30.                 stmt = conn.createStatement();
  31.                 // 4、执行sql语句
  32.                 String sql = "select * from t_user where login_name='"+loginName+"'and login_pwd='"+loginPwd+"'";
  33.                 System.out.println(sql);
  34.                 //程序执行到此处，才会将以上的sql语句发送到DBMS上，DBMS进行sql语句的编译。
  35.                 rs = stmt.executeQuery(sql);//sql处理后会返回一个处理集，
  36.                 //如果以上sql语句中用户名和密码是正确的，那么结果集最多也就查询出一条记录，所以以下不需要while循环。if就够了
  37.                 if(rs.next()){//此条件如果成立，表示登录成功
  38.                   ok=true;
  39.                 }
  40.                 // 5、处理结果集
  41.             } catch (Exception e) {
  42.                 e.printStackTrace();
  43.             }finally {
  44.                 // 6、释放资源
  45.                 if (rs != null) {
  46.                     try {
  47.                         rs.close();
  48.                     } catch (SQLException throwables) {
  49.                         throwables.printStackTrace();
  50.                     }
  51.                 }
  52.                 if (stmt != null) {
  53.                     try {
  54.                         stmt.close();
  55.                     } catch (SQLException throwables) {
  56.                         throwables.printStackTrace();
  57.                     }
  58.                 }
  59.                 if (conn!= null) {
  60.                     try {
  61.                         conn.close();
  62.                     } catch (SQLException throwables) {
  63.                         throwables.printStackTrace();
  64.                     }
  65.                 }
  66.             }
  68.              return ok;
  69.         }
  72.     private static Map<String, String> initUI(){
  73.          System.out.println("欢迎使用该系统，请输入用户名和密码进行身份认证");
  74.          Scanner s=new Scanner(System.in);
  75.          System.out.println("用户名：");
  76.          String loginName=s.nextLine();
  77.          System.out.println("密码：");
  78.          String loginPwd=s.nextLine();
  79.          //将用户名和密码放在map集合中
  80.          Map<String,String> useLoginInfo=new HashMap<>();
  81.          useLoginInfo.put("loginName",loginName);
  82.          useLoginInfo.put("loginPwd",loginPwd);
  83.          //返回map
  84.          return useLoginInfo;
  86.      }
  88. /*
  89. 随便输入一个用户名的密码，登录成功了，这种现象被称为SQL注入现象！
  90. 导致SQL注入的根本原因是：用户不是一般的用户，用户是懂程序的，输入的用户名信息以及密码信息中，
  91. 含有SQL语句的关键词，这个SQL语句的关键字和底层的SQL语句进行“字符串拼接”，导致原SQL语句的含义
  92. 被扭曲了。最最主要的原因是：用户提供的信息参与了SQL语句的编译。
  94. 主要因素，这个程序是先进行字符串的拼接，然后再进行sql语句的编译，正好彼注入。
  95. 用户名：
  96. fdsa
  97. 密码：
  98. fdsa' or '1'='1
  99. select * from t_user where login_name='fdsa'and login_pwd='fdsa' or '1'='1'
  100.  */
  103. }

解决SQL注入问题(重点学习）

JDBCTest07 

  1. package jdbc;
  3. import java.sql.*;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Scanner;
  7. /*
  8.  怎么避免sql注入？
  9.  sql注入的根本原因是，先进行了字符串的拼接，然后在进行的编译。
  11.   java.sql.Statement接口的特点，先进行字符串的拼接。然后再进行sql语句的编译。
  12.   优点：使用Statement可以进行sql语句的拼接。
  13.   缺点：因为拼接的存在，导致可能给不法分子机会。
  15.   java.sql.PreparedStatement接口的特点，先进行sql语句的编译，然后在进行sql语句的传值。
  16.    优点：避免sql注入。
  17.    缺点:没有办法进行sql语句的拼接，只能给sql语句传值。
  18.    PreparedStatement预编译的数据库操作对象
  19. */
  21. public class jdbc07 {
  22.     public static void main(String[] args) {
  23.         //初始化一个界面，可以让用户输入用户名和密码
  24.         Map<String,String>userLoginInfo=initUI();
  25.         //连接数据库验证用户和密码是否正确
  26.         boolean ok=checkNameAndPwd(userLoginInfo.get("loginName"),userLoginInfo.get("loginPwd"));
  27.         System.out.println(ok?"登陆成功":"登陆失败");
  29.     }
  31.     private static boolean checkNameAndPwd(String loginName, String loginPwd) {
  32.         boolean ok=false;//默认登录是失败的，
  33.         Connection conn = null;
  34.         PreparedStatement stmt = null;
  35.         ResultSet rs = null;
  37.         // 1、注册驱动
  38.         try {
  39.             Class.forName("com.mysql.cj.jdbc.Driver");
  40.             // 2、获取连接
  41.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  42.             // 3、获取预编译的数据库操作对象
  43.             //一个问号是一个占位符，一个占位符只能接收一个值/数据
  44.             String sql = "select * from t_user where login_name=? and login_pwd=?";
  45.              stmt=conn.prepareStatement(sql);//此时会发送sql给DBMS，进行sql语句的编译
  46.             //给占位符?传值
  47.             //怎么解决sql注入的？即使用户信息中有sql关键字，但是不参加编译就没事。
  48.             //stmt.setInt(1,100);//这样必须是填数字，↓下面那个必须填字符串。
  49.             stmt.setString(1,loginName);//给第一个占位符传值
  50.             stmt.setString(2,loginPwd);//给第二个占位符传值
  51.             // 4、执行sql语句
  52.             rs = stmt.executeQuery();//这个方法不需要将sql语句传递进去，不能是这样：rs = stmt.executeQuery(sql);因为上面已经把sql传过去了。
  53.             if(rs.next()){//此条件如果成立，表示登录成功
  54.                 ok=true;
  55.             }
  56.             // 5、处理结果集
  57.         } catch (Exception e) {
  58.             e.printStackTrace();
  59.         }finally {
  60.             // 6、释放资源
  61.             if (rs != null) {
  62.                 try {
  63.                     rs.close();
  64.                 } catch (SQLException throwables) {
  65.                     throwables.printStackTrace();
  66.                 }
  67.             }
  68.             if (stmt != null) {
  69.                 try {
  70.                     stmt.close();
  71.                 } catch (SQLException throwables) {
  72.                     throwables.printStackTrace();
  73.                 }
  74.             }
  75.             if (conn!= null) {
  76.                 try {
  77.                     conn.close();
  78.                 } catch (SQLException throwables) {
  79.                     throwables.printStackTrace();
  80.                 }
  81.             }
  82.         }
  84.         return ok;
  85.     }
  88.     private static Map<String, String> initUI(){
  89.         System.out.println("欢迎使用该系统，请输入用户名和密码进行身份认证");
  90.         Scanner s=new Scanner(System.in);
  91.         System.out.println("用户名：");
  92.         String loginName=s.nextLine();
  93.         System.out.println("密码：");
  94.         String loginPwd=s.nextLine();
  95.         //将用户名和密码放在map集合中
  96.         Map<String,String> useLoginInfo=new HashMap<>();
  97.         useLoginInfo.put("loginName",loginName);
  98.         useLoginInfo.put("loginPwd",loginPwd);
  99.         //返回map
  100.         return useLoginInfo;
  102.     }
  105. }

一个 ？ 表示一个占位符

规律：就是第三步写好SQL语句，用占位符，然后给占位符传值

知识点的补充：当写第一个SQL语句时，会编译然后执行，若你后面在写一模一样的SQL语句就不会编译，直接执行。

Statement使用场景

JDBCTest8 必须使用SQL注入

先使用PreparedStatement-

这个程序输入desc或者asc会出错，因为
select ename,sal from emp order by sal ?会被换成select ename,sal from emp order by sal ‘desc’而不是select ename,sal from emp order by sal desc ，

PreparedStatement比较适合传值，Statement比较适合进行字符串的拼接。

京东升降序那不让用户输入，就是不给你注入的机会。


  1. package jdbc;
  3. import java.sql.*;
  4. import java.util.Scanner;
  6. /*
  7. *需求：用户再控制台上输入desc则降序，输入asc则升序。
  8. *思考以下，这个应该选择Statement还是PreparedStatement
  9. 选Statement,y因为PreparedStatement只能传值，不能进行sql语句的拼接。
  10.  */
  11. public class jdbc08 {
  12.      public static void main(String[] args){
  13.          Scanner s=new Scanner(System.in);
  14.          System.out.print("请输入desc或asc[desc是表示降序，asc表示升序]：");
  15.             //用户输入的
  16.          String orderKey=s.next();
  17.          //先使用PreparedStatement
  18.          Connection conn = null;
  19.          PreparedStatement ps = null;
  20.          ResultSet rs = null;
  21.          try {
  22.              //1、注册驱动
  23.              Class.forName("com.mysql.cj.jdbc.Driver");
  24.              //2、获取连接
  25.              conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  26.              //3、获取预编译的数据库操作对象
  27.              String sql="select ename,sal from emp order by sal ?";
  28.              ps=conn.prepareStatement(sql);
  29.              //给？传值
  30.              ps.setString(1,orderKey);
  31.              //4、执行sql语句
  32.              rs=ps.executeQuery();
  33.              while(rs.next()){
  34.                  String ename=rs.getString("ename");
  35.                  String sal=rs.getString("sal");
  36.                  System.out.println(ename+","+sal);
  37.              }
  40.          } catch (Exception e) {
  41.              e.printStackTrace();
  42.          }finally {
  43.              if(rs!=null){
  44.                  try {
  45.                      rs.close();
  46.                  } catch (SQLException e) {
  47.                      e.printStackTrace();
  48.                  }
  49.              }
  50.              if(ps!=null){
  51.                  try {
  52.                      ps.close();
  53.                  } catch (SQLException e) {
  54.                      e.printStackTrace();
  55.                  }
  56.              }
  57.              if(conn!=null){
  58.                  try {
  59.                      conn.close();
  60.                  } catch (SQLException e) {
  61.                      e.printStackTrace();
  62.                  }
  63.              }
  64.          }
  67.      }
  68. }

JDBCTest09
再使用statement,此时可以执行了

  1. package jdbc;
  3. import java.sql.*;
  4. import java.util.Scanner;
  6. /*
  7.  *需求：用户再控制台上输入desc则降序，输入asc则升序。
  8.  *思考以下，这个应该选择Statement还是PreparedStatement
  9.  */
  10. public class jdbc09 {
  11.     public static void main(String[] args){
  12.         Scanner s=new Scanner(System.in);
  13.         System.out.print("请输入desc或asc[desc是表示降序，asc表示升序]：");
  14.         //用户输入的
  15.         String orderKey=s.next();
  16.         //再使用Statement
  17.         Connection conn = null;
  18.         Statement stmt = null;
  19.         ResultSet rs = null;
  20.         try {
  21.             //1、注册驱动
  22.             Class.forName("com.mysql.cj.jdbc.Driver");
  23.             //2、获取连接
  24.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  25.             //3、获取数据库操作对象
  26.             stmt = conn.createStatement();
  27.             //4、执行sql语句
  28.             String sql="select ename,sal from emp order by sal "+orderKey;
  29.             rs=stmt.executeQuery(sql);
  30.             while(rs.next()){
  31.                 String ename=rs.getString("ename");
  32.                 String sal=rs.getString("sal");
  33.                 System.out.println(ename+","+sal);
  34.             }
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }finally {
  40.             if(rs!=null){
  41.                 try {
  42.                     rs.close();
  43.                 } catch (SQLException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.             if(stmt!=null){
  48.                 try {
  49.                     stmt.close();
  50.                 } catch (SQLException e) {
  51.                     e.printStackTrace();
  52.                 }
  53.             }
  54.             if(conn!=null){
  55.                 try {
  56.                     conn.close();
  57.                 } catch (SQLException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.         }
  64.     }
  65. }

使用PreparedStatement完成增删改

  1. package jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.SQLException;
  8. public class jdbc10 {
  9.     public static void main(String[] args) {
  10.         Connection conn=null;
  11.         PreparedStatement ps=null;
  12.         try {
  13.             //1、注册驱动
  14.             Class.forName("com.mysql.cj.jdbc.Driver");
  15.             //2、获取连接
  16.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  17.             //3、获取预编译的数据库操作对象
  18.            //增加操作
  19.             /*String sql="insert into dept(deptno,dname,loc) values(?,?,?)";
  20.             ps=conn.prepareStatement(sql);
  21.             //给？传值
  22.             ps.setInt(1,50);
  23.             ps.setString(2,"销售部");
  24.             ps.setString(3,"天津");*/
  26.             //更新操作
  27.           /*  String sql="update dept set dname=?,loc=? where deptno = ?";
  28.             ps=conn.prepareStatement(sql);
  29.             ps.setString(1,"软件研发部");
  30.             ps.setString(2,"北京");
  31.             ps.setInt(3,50);*/
  32.            //删除操作
  33.             String sql="delete from dept where deptno = ?";
  34.             ps=conn.prepareStatement(sql);
  35.             ps.setInt(1,50);
  36.             // 4、执行sql
  37.             int count=ps.executeUpdate();
  38.             System.out.println(count);
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.         }finally {
  42.             //6、释放资源
  43.             if(ps!=null){
  45.                 try {
  46.                     ps.close();
  47.                 } catch (SQLException e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.             if(conn!=null){
  52.                 try {
  53.                     conn.close();
  54.                 } catch (SQLException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.         }
  61.     }
  62. }

模糊查询

  1. package jdbc;
  3. import java.sql.*;
  5. public class jdbc11 {
  6.     public static void main(String[] args) {
  7.         Connection conn=null;
  8.         PreparedStatement ps=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://127.0.0.1:3306/bjpowernode", "root", "123456");
  15.             //3、获取预编译的数据库操作对象
  16.             //找出名字中含有O的
  17.             //以下第一种方法是错误的，因为？不能放在单引号内
  18.             /*String sql="select ename from emp where ename like '%?%'";
  19.             ps=conn.prepareStatement(sql);
  20.             ps.setString(1, "O");*/
  21.             String sql="select ename from emp where ename like ?";
  22.             ps=conn.prepareStatement(sql);
  23.             ps.setString(1, "%O%");
  24.             // 4、执行sql
  25.             rs=ps.executeQuery();
  26.              while (rs.next()){
  27.                System.out.println(rs.getString("ename"));
  28.            }
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         }finally {
  33.             //6、释放资源
  34.             if(ps!=null){
  36.                 try {
  37.                     ps.close();
  38.                 } catch (SQLException e) {
  39.                     e.printStackTrace();
  40.                 }
  41.             }
  42.             if(conn!=null){
  43.                 try {
  44.                     conn.close();
  45.                 } catch (SQLException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.             }
  49.             if(ps!=null){
  50.                 try {
  51.                     ps.close();
  52.                 } catch (SQLException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.             }
  56.         }
  59.     }
  60. }

JDBC 里面的事务

JDBCTest10 测试JDBC里面的事务自动提交【需要手动关掉自动提交】

JDBCTest11 账户转账演示事务【JDBC的事务控制，基于单机事务】
知识点补充：有效数字，从左边起，不为0的数字为有效数字

快捷键补充：ait+shift+inster 可以复制前面不带 * 号的内容 也可以批量编辑

如果程序在执行过程中，有异常，就得手动回滚，保证数据的安全性

JDBC工具类的封装

  • 外部文件

    1. driver=com.mysql.cj.jdbc.Driver
    2. url=jdbc:mysql://127.0.0.1:3306/bjpowernode
    3. user=root
    4. password=123456

  • 封装类 ```css package jdbc.utils; //在一个没有结束的程序中，DBUtil这个类只加载一次

import java.sql.*; import java.util.ResourceBundle;

/ 数据库工具类，便于JDBC的代码编写 / public class DBUtil { //静态变量和静态代码块的执行时候是一样的,先出现的先执行 //构造方法私有化是为了防止new对象，为什么要防止用对象？ //因为工具类中的方法都是静态的，不需要new对象，直接用“类名.”的方式调用 private DBUtil(){};//工具类的构造方法私有化的 //类加载时绑定属性资源文件 private static ResourceBundle bundle=ResourceBundle.getBundle(“jdbcc”);

  1. //保证注册驱动在类加载的时执行且只执行一次，则使用静态代码块

static{ try { Class.forName(bundle.getString(“driver”)); } catch (ClassNotFoundException e) { e.printStackTrace(); } }

  1.  //获得数据库连接对象
  2.  public static Connection getConnection() throws SQLException {
  3.    String url=bundle.getString("url");
  4.    String user=bundle.getString("user");
  5.    String password=bundle.getString("password");
  6.    Connection conn=DriverManager.getConnection(url,user,password);
  7.     return conn;
  8.  }
  9. /**
  10.  * 释放资源
  11.  * conn 连接对象
  12.  * stmt 数据库操作对象
  13.  * rs 查询结果集
  14.  */
  15. public static void close(Connection conn, Statement stmt,ResultSet rs){
  16.       if(rs!=null){
  17.           try {
  18.               rs.close();
  19.           } catch (SQLException e) {
  20.               e.printStackTrace();
  21.           }
  22.       }
  23.       if(stmt!=null){
  24.           try {
  25.               stmt.close();
  26.           } catch (SQLException e) {
  27.               e.printStackTrace();
  28.           }
  29.       }
  30.       if(conn!=null){
  31.           try {
  32.               conn.close();
  33.           } catch (SQLException e) {
  34.               e.printStackTrace();
  35.           }
  36.       }
  39.   }

}

  3. 测试类
  4. ```css
  5. package jdbc;
  7. import java.sql.*;
  9. public class jdbc11 {
  10.     public static void main(String[] args) {
  11.         Connection conn=null;
  12.         PreparedStatement ps=null;
  13.         ResultSet rs=null;
  14.         try {
  15.             //1、注册驱动
  16.             Class.forName("com.mysql.cj.jdbc.Driver");
  17.             //2、获取连接
  18.             conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/bjpowernode", "root", "123456");
  19.             //3、获取预编译的数据库操作对象
  20.             //找出名字中含有O的
  21.             //以下第一种方法是错误的，因为？不能放在单引号内
  22.             /*String sql="select ename from emp where ename like '%?%'";
  23.             ps=conn.prepareStatement(sql);
  24.             ps.setString(1, "O");*/
  25.             String sql="select ename from emp where ename like ?";
  26.             ps=conn.prepareStatement(sql);
  27.             ps.setString(1, "%O%");
  28.             // 4、执行sql
  29.             rs=ps.executeQuery();
  30.              while (rs.next()){
  31.                System.out.println(rs.getString("ename"));
  32.            }
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             //6、释放资源
  38.             if(ps!=null){
  40.                 try {
  41.                     ps.close();
  42.                 } catch (SQLException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.             if(conn!=null){
  47.                 try {
  48.                     conn.close();
  49.                 } catch (SQLException e) {
  50.                     e.printStackTrace();
  51.                 }
  52.             }
  53.             if(ps!=null){
  54.                 try {
  55.                     ps.close();
  56.                 } catch (SQLException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.             }
  60.         }
  63.     }
  64. }

JDBC 里面的行级锁

1.行级锁的理解：
image.png
在 select 语句后面添加了 for update 就表示 emp 表 中工作岗位等于 MANAGER 的行级记录谁都不能动，这叫行级锁
当前事务没有结束的时候，表中那三行记录，就不能动，其它事务无法对着三行记录，进行操作。
行级锁，又被称为悲观锁

关于DQL语句的悲观锁
对于一个DQL语句来说，末尾是可以添加这样一个关键字的：for update

select ename,sal from emp where job=‘MANAGER’ for update ;
以上sql语句的含义是：
在本次事务的执行过程中，job=’MANAGER’的记录被查询，
这些记录在我查询的过程中，任何人，任何事务都不能对
这些记录进行修改操作，直到我当前事务结束。

这种机制被称为：行级锁机制（又叫做悲观锁！）

在mysql中是这样的，
当使用select…where…for updare…时，mysql进行row lock（行锁）还是table lock（表锁）只取决于是否能使用索引（例如主键，unique字段），能则为行锁，否则为表锁：
未查到数据则无锁，而使用’<>’,’like’等操作时，索引会失效，自然进行的是table lock。

所以慎用for update。

整个表锁住的时候会导致性能性能降低，谨慎使用。

使用for update的时候，最好是锁主键值，或者具有unique约束的字段，
锁别的字段可能会导致整个表锁住

  • 逛敲逛练，不用 idea 开发工具，手写出JDBC开发的六步，熟练掌握JDBC里面的代码

  • 挑选一道作业题写到 Java 语句里面