• 【MySQL系列】Java的JDBC编程

    ☕目录☕

          🍚前言

                🍜一、背景知识引入

                🥡二、安装MySQL数据库驱动包，并且导入到项目中

                🧇三、JDBC的使用

                            🥩🥩3.1 JDBC插入数据操作

                            🍛🍛3.2 JDBC修改数据操作

                            🍣🍣3.3 JDBC删除数据操作

                            🍔🍔3.4 JDBC查找数据操作

          🍱后续

    前言

    在之前学习MySQL数据库的时候，也许有的同学在纠结于使用 命令行的方式，还是图形化界面的方式 来学习~~

    其实，在日常开发过程中，主流使用方式其实是通过代码的形式来操作数据库~~

    当然，无论是使用哪种方式，其核心知识都是 SQL~~

     

    一、背景知识引入

    MySQL是一个 客户端/服务器 结构的程序~

    当然，不是所有的数据库都是这样的（SQLite就不是，Oracle、SQL Server是）~

    像主流的数据库，为了方便程序员实现 客户端 程序，会提供一些 API接口，称为 "数据库SDK"，就可以借助这些 API接口，比较方便的访问数据库服务器~~

    API，是计算机中一个相当广泛使用的术语，Application Programming Interface ，提供了一些 函数/方法/类，可以让程序员直接调用来完成一些功能~~ 

     SDK，也是一个相当广泛使用的术语，Software Development Kit，软件开发工具包，提供了一些工具~~

    比如说，张三同学有了一个女朋友，那么此时女朋友可以给张三提供一些API，如 日常拉拉小手，日常抱一抱......

    就类似于，数据库服务器给我们提供了一些API，比如说 可以调用这个函数 连接到数据库；调用这个函数 执行一些SQL操作；调用这个函数 来关闭连接；调用这个函数，来创建一个事务；...... 

    现在这里就引入了一个问题：

    API 是数据库提供的，而不同的数据库，提供的 API 风格（里面的类名、方法名、参数/返回值 等都不同）可能不一样，那怎么办？？？ 

    于是，Java 提出了一套 "标准"的接口体系（毕竟，也不会找数据库本身的）~~

    让这些数据库厂商，提供的API都往 Java 的这套接口体系中进行适配~~

    程序员只要去掌握 Java 的这一套 API 即可适应所有的主流数据库了~~

    当然，其他大多数主流编程语言，也有类似的操作~~

    主流数据库，都会有多语言支持~~

    现在，咱们说的是 Java~~

    而Java所提供的这套API，就叫做 JDBC~~

     

    而各个数据库厂商，为了能够适配 JDBC，因此就需要写一些额外的程序 来完成这个工作，厂商提供的这套额外的程序，称为 "JDBC驱动包"~~

    当我们使用Java操作MySQL的时候，就需要去安装MySQL的驱动包；

    当我们使用Java操作各种数据库，就需要安装对应的 数据库所提供的驱动包，才能真正进行使用~~ 

    JDBC 本质上就是 Java对于各种数据库差异性的封装~

    目的就是为了简化程序员的学习使用成本~ 

     

    二、安装MySQL数据库驱动包，并且导入到项目中

    我们使用Java操作MySQL数据库的时候，肯定是要安装MySQL数据库驱动包的~~

    现在，这里就来分享一下 如何在 "中央仓库" 下面下载一下MySQL数据库驱动包~~

    搜索 "中央仓库" 网址：https://mvnrepository.com/

    虽然这一步骤加载过程可能有点慢~~ 

     

    下载好了以后，就会得到一个 .jar后缀的文件，叫做 jar 包 ~

    本质上就是一个类似于 rar 的压缩包~

    jar 包里面主要就是一些 .class文件~

    像这样的压缩包，不需要我们手动解压缩，直接放到项目中即可~

    JVM 在运行的时候能自动的读取压缩包里面的内容~

    接下来我们就需要把准备好的 jar 包，放入到项目里面去~~

    第一步，我们需要创建一个目录，并且把 jar 包拷贝到目录里面去：

     

     

    第二步，设置这个目录，让这个目录能被项目识别：

      

     

    三、JDBC的使用

    3.1 JDBC插入数据操作

    由于MySQL是一个服务器，要想和服务器之间进行通信，前提是需要和 服务器之间进行连接；

    要想和服务器之间建立连接，前提是需要知道服务器所在的位置~~

    第一个环节：

    在JDBC里面，使用 DataSource 这个类来描述数据库的位置：

    1. DataSource dataSource = new MysqlDataSource();
    2.  
    3. --DataSource 是一个 interface,不能直接实例化~~
    4. --而 MysqlDataSource 则是实现了 DataSource接口~~
    5.  
    6. --实际上，这个操作，就是 "向上转型"~~

    需要注意的是，这个类来自于驱动包，如果驱动包导入正确，才能够顺利的提示出来：

    通过 DataSource 来确定服务器的位置~~

    位置如何描述？

    描述一个网络上的资源，常用手段 就是使用 URL（唯一资源定位符/网址）~~ 

    1. ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306/java?characterEncoding=utf8&useSSL=false");
    2.  
    3. --((MysqlDataSource)dataSource).setUrl();
    4. --这是一个向下转型
    5.  
    6. --其中，
    7.  
    8. --jdbc:mysql 是协议名，即 这个网址是干啥用的(这个网址就是 jdbc 连 mysql用)
    9.  
    10. --127.0.0.1 是IP地址(互联网上的主机的IP地址，是通过一串的数字的形式来描述的)
    11.  
    12. --3306 是端口号(用于区别 当前主机上的哪个程序，MySQL服务器默认使用的端口号是 3306)
    13.  
    14. --java 是数据库名,就是 create database 数据库名,访问的是MySQL数据库上面的哪一个数据库
    15.  
    16. --characterEncoding=utf8&useSSL=false 是一些相关参数,
    17. --characterEncoding=utf8 是设置客户端连接服务器使用的字符集
    18. --useSSL=false 固定设为false,表示不启用加密

    像上述URL，大家不必去背！！！

    背，容易背错！！！

    写了一次之后，后续只要去复制粘贴即可！！！ 

    同时，需要设置用户名以及密码：

    1. //设置用户名 是固定的 root
    2. ((MysqlDataSource)dataSource).setUser("root");
    3.  
    4. //设置密码 不是固定的,是自己的数据库密码
    5. ((MysqlDataSource)dataSource).setPassword("111111");

     以上操作，就可以准确的描述服务器的位置~~

    网络通信中，有两种风格：

    一种是 "有连接"，相当于 "打电话" （接通电话过后，才可进行聊天）

    一种是 "无连接"，相当于 "发微信" （编辑信息后，爱看不看，信息都已经发过去了）

    数据库这里的通信方式，采取的是有连接的方式~

    优点：能够在通信之前，知道通信的链路是否通畅

    缺点：连接需要进行管理，尤其是不用的连接要及时释放（想像 打完电话要挂断，否则扣你话费）~~

    第二个环节：

     和数据库服务器建立连接：

    Connection connection = dataSource.getConnection();

    啥时候会出现异常：和数据库服务连接失败~~

    Alt + Enter，出现 解决方案~~ 

    如果连接失败，失败的原因有很多，DataSource 这里填写的信息，有一点点的纰漏，就会导致连接失败~~

    第三个环节：
    构造SQL语句（JDBC操作数据库，本质仍然是通过 SQL 来描述数据库操作）~~ 

    例如，此时我们进行一个插入数据的操作：

    首先我们需要一个表：

      

    第四个环节：

    执行SQL语句，

    insert、update、delete都是通过executeUpdate来执行的，

    select则是通过exexuteQuery来执行的~~

     executeUpdate 的返回值是一个整数，表示这个操作影响到几行，

    就类似于：

    第五个环节：

    断开连接，释放资源

    释放顺序：后创建的先释放

    运行结果：

    如果在创建表的时候，设置了主键约束，

    比如说，id设置成了主键，

    那么 如上述情况的话，运行第二次就会报错：id唯一 存在主键约束~~

    可是，这样的话，插入的数据就会写死了~~

    而在实际操作过程中，这种写死的办法并不好~~

    我们还需要用其他的办法来进行操作~~

    此时，自己可输入数据：
     

    附：

    JDBC插入操作 源码：

    1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.SQLException;
    7. import java.sql.SQLOutput;
    8. import java.util.Scanner;
    9.  
    10. public class JDBCHello {
    11.     public static void main(String[] args) throws SQLException {
    12.         //1.使用 DataSource 来描述 MySQL服务器的位置
    13.         DataSource dataSource = new MysqlDataSource();
    14.         ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306" +
    15.                 "/java?characterEncoding=utf8&useSSL=false");
    16.         //设置用户名 是固定的 root
    17.         ((MysqlDataSource)dataSource).setUser("root");
    18.         //设置密码 不是固定的,是自己的数据库密码
    19.         ((MysqlDataSource)dataSource).setPassword("111111");
    20.  
    21.         //2.和数据库服务器建立连接
    22.         Connection connection = dataSource.getConnection();
    23.         //System.out.println(connection);
    24.  
    25.         //3.构造SQL语句
    26.         //例如，此时我们进行一个插入数据的操作
    27.         Scanner scanner = new Scanner(System.in);
    28.         System.out.println("请输入学号：");
    29.         int num = scanner.nextInt();
    30.         System.out.println("请输入姓名：");
    31.         String name = scanner.next();
    32.  
    33.         String sql = "insert into student values(?,?)";
    34.         //使用？作为占位符，后续使用statement 对象针对？进行替换~
    35.         //直接用 String格式的SQL还不行,还需要搭配一个特殊的类 —— PreparedStatement
    36.         PreparedStatement statement = connection.prepareStatement(sql);
    37.  
    38.         statement.setInt(1,num);//第一个问号，代替成num,此处的下标，从1开始计数的
    39.         statement.setString(2,name);
    40.         //通过上面两个参数的替换，把第1个参数替换为 num，第2个参数替换为 name
    41.         System.out.println(statement);
    42.  
    43.         //4.执行 SQL语句
    44.         int n = statement.executeUpdate();
    45.         System.out.println("n = " + n);
    46.  
    47.         //5.断开连接,释放资源(后创建的先释放)
    48.         statement.close();
    49.         connection.close();
    50.     }
    51. }

     

    3.2 JDBC修改数据操作

    实现数据库修改的操作，和插入操作非常类似~~

    只是这里的 SQL语句 是 update语句~~

     

    1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.SQLException;
    7. import java.util.Scanner;
    8.  
    9. public class JDBCUpdate {
    10.     public static void main(String[] args) throws SQLException {
    11.         //实现数据库的修改操作，和插入非常相似
    12.         //只是这里构造的 SQL 语句是 update 语句
    13.  
    14.         //1.构造数据源
    15.         DataSource dataSource = new MysqlDataSource();
    16.         ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306" +
    17.                 "/java?characterEncoding=utf8&useSSL=false");
    18.         ((MysqlDataSource)dataSource).setUser("root");
    19.         ((MysqlDataSource)dataSource).setPassword("111111");
    20.  
    21.         //2.和数据库建立连接
    22.         Connection connection = dataSource.getConnection();
    23.  
    24.         //3.用户输入，要修改的id和输入后的名字
    25.         Scanner scanner = new Scanner(System.in);
    26.         System.out.println("请输入要修改的同学学号：");
    27.         int id = scanner.nextInt();
    28.         System.out.println("请输入要修改之后的同学姓名：");
    29.         String  name = scanner.next();
    30.         //next 读到空白符(空格，制表符，换行符，回车符，垂直制表符......)
    31.         //nextLine 读到换行符
    32.  
    33.         //4.构造SQL语句
    34.         String sql = "update student set name = ? where id = ?";
    35.         PreparedStatement statement = connection.prepareStatement(sql);
    36.         statement.setString(1,name);
    37.         statement.setInt(2,id);
    38.         System.out.println(statement);
    39.  
    40.         //5.执行SQL
    41.         int n = statement.executeUpdate();
    42.         System.out.println("n = "+ n);
    43.  
    44.         //6.关闭连接、释放资源
    45.         statement.close();
    46.         connection.close();
    47.  
    48.     }
    49. }

    3.3 JDBC删除数据操作

    删除数据库中的数据，代码的写法和前面的增加/修改 是类似的~~

    只是这里的 SQL语句是 delete语句~

    1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.SQLException;
    7. import java.util.Scanner;
    8.  
    9. public class JDBCDelete {
    10.     public static void main(String[] args) throws SQLException {
    11.         //删除数据库中的数据，代码的写法和前面的增加/修改 是类似的
    12.  
    13.         //1.构造数据源
    14.         DataSource dataSource = new MysqlDataSource();
    15.         ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306" +
    16.                 "/java?characterEncoding=utf8&useSSL=false");
    17.         ((MysqlDataSource)dataSource).setUser("root");
    18.         ((MysqlDataSource)dataSource).setPassword("111111");
    19.  
    20.         //2.和数据库建立连接
    21.         Connection connection = dataSource.getConnection();
    22.  
    23.         //3.输入删除的内容
    24.         Scanner scanner = new Scanner(System.in);
    25.         System.out.println("请输入要删除的同学id：");
    26.         int id = scanner.nextInt();
    27.  
    28.         //4.构造SQL语句
    29.         String sql = "delete from student where id = ?";
    30.         PreparedStatement statement = connection.prepareStatement(sql);
    31.         statement.setInt(1,id);
    32.         System.out.println(statement);
    33.  
    34.         //5.执行SQL
    35.         int n = statement.executeUpdate();
    36.         System.out.println("n = "+ n);
    37.  
    38.         //6.关闭连接、释放资源
    39.         statement.close();
    40.         connection.close();
    41.  
    42.     }
    43. }

    3.4 JDBC查找数据操作

    查找数据库中的记录~~

    这个查找操作就和前面的操作不太一样了~~

    多了一个步骤 —— 要遍历结果集合~~

    1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8.  
    9. public class JDBCSelect {
    10.     public static void main(String[] args) throws SQLException {
    11.         //查找数据库中的记录~~
    12.         //查找操作需要遍历结果集合，这是前面的几个操作不曾有的~~
    13.         //因为客户端 后面拿到的是 "临时表"，必须遍历一遍取出里面所需的东西 再显示在黑框框上~~
    14.  
    15.         //1.构造数据源
    16.         DataSource dataSource = new MysqlDataSource();
    17.         ((MysqlDataSource)dataSource).setUrl("jdbc:mysql://127.0.0.1:3306" +
    18.                 "/java?characterEncoding=utf8&useSSL=false");
    19.         ((MysqlDataSource)dataSource).setUser("root");
    20.         ((MysqlDataSource)dataSource).setPassword("111111");
    21.  
    22.         //2.和数据库建立连接
    23.         Connection connection = dataSource.getConnection();
    24.  
    25.         //3.此处就不输入条件了，直接查找所有记录
    26.  
    27.         //4.构造SQL
    28.         String sql = "select * from student";
    29.         PreparedStatement statement = connection.prepareStatement(sql);
    30.  
    31.         //5.执行SQL
    32.         //此处要使用的是 executeQuery
    33.         //executeUpdate 只能返回一个int
    34.         //executeQuery 返回的是一个 ResultSet对象，可以把这个对象视为一个 "临时表"~~
    35.         ResultSet resultSet = statement.executeQuery();
    36.  
    37.         //6.遍历 "临时表"
    38.         //resultSet 简单的当成一个类似于 "迭代器" 这样的东西来看待~~
    39.         //next 如果没有到达末尾，就是返回true，要继续循环
    40.         //next 如果到达了末尾，就返回false，结束循环
    41.         while (resultSet.next()){
    42.             //在这里就可以取这一行的数据了
    43.             //通过 ResultSet 里面的 getXXX方法，来获取到这里指定的列
    44.  
    45.             //取id，id是整数，getInt
    46.             int id =resultSet.getInt("id");
    47.  
    48.             //取name，name是字符串，getString
    49.             String name = resultSet.getString("name");
    50.             System.out.println(id + ":" + name);
    51.         }
    52.  
    53.  
    54.         //7.关闭连接，释放资源
    55.         resultSet.close();
    56.         statement.close();
    57.         connection.close();
    58.  
    59.     }
    60.     
    61. }

    关于JDBC整体的代码就是上述这样的~~

    不难~~

    但是比较繁琐~~

    务必 掌握这里的核心概念（DataSource、Connection、PreparedStatement、ResultSet......），并且需要掌握核心流程~~

     

     

     

    后续

    实际在开发中，很少会直接使用JDBC~~

    JDBC 写起来比较麻烦，比较啰嗦~~

    后来衍生出了许多 "框架"，能够简化数据库操作~~

    比如说，后面会介绍的 MyBatis框架~~

    好啦~~

    这就是MySQL数据库JDBC编程的内容啦~~

    如果这篇博客给你带来了收获~~

    可以留下一颗小小的赞吗~~

     

  • 相关阅读:
    深入了解Spring Boot Actuator
    批量修改文件名，给文件名称插入文字信息
    激光雷达数据为例滤波器
    在Thymeleaf中使用th:href标记构建 URL
    SQL经典练习题（openGauss数据库）上
    第十四届全国大学生数学竞赛决赛（非数类）游记+答案解析
    网康科技 NS-ASG 应用安全网关 SQL注入漏洞复现(CVE-2024-2330)
    LeetCode排序链表C++解法（详解）
    杰理之可能出现有些芯片音乐播放速度快【篇】
    CSP-J1 CSP-S1 初赛 第1轮 数学问题（数论、排列组合等）
  • 原文地址：https://blog.csdn.net/qq_53362595/article/details/125947149