MySQL--浅析JDBC及简单操作

最新推荐文章于 2024-06-01 10:35:00 发布
最新推荐文章于 2024-06-01 10:35:00 发布
阅读量141 收藏
点赞数
文章标签： 数据库 mysql java jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43289569/article/details/104165341
版权

一、什么是JDBC
1、概念
JDBC由一组用Java语言编写的类和接口组成，是Java和数据库之间的一个桥梁，是一个规范，而不是一个实现，能够执行SQL语句。
2、各种不同类型的数据库都有相应的实现
所有不同类型数据库的开发商依照这这种规范编写了相应Java代码以提供相应的操作数据库的方法。
在这里插入图片描述
3、关于数据库的执行流程
在这里插入图片描述
二、用JDBC访问MySQL
1、配置
（1）导入相关依赖

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.31</version>
    </dependency>

（2）参数配置

        pro = new Properties();
        try {//参数配置
            pro.load(new FileInputStream("D:\\db.properties"));
            jdbcDriver = pro.getProperty("jdbcDriver");
            jdbcUrl = pro.getProperty("jdbcUrl");
            userName = pro.getProperty("userName");
            password = pro.getProperty("password");
        } catch (IOException e) {
            e.printStackTrace();
        }

（3）建立连接

public void getConnection(){
        try {
            Class.forName(jdbcDriver);//加载驱动
            connection = DriverManager.getConnection(jdbcUrl,userName,password);//建立连接
            if(connection.isClosed()){
                System.out.println("连接建立失败");
            }
            System.out.println("连接建立成功");
//获取对象，对数据库中的表进行操作时使用的对象，所有操作数据库表的方法都在这个statement之下
            statement = connection.createStatement();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

2、具体操作示例
（1）操作数据库的对象为Statement

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

public class JdbcTest {
    private String jdbcDriver;
    private String jdbcUrl;
    private String userName;
    private String password;
    private Properties pro;
    private Connection connection;
    private Statement statement; //操作数据库的对象

    public JdbcTest(){
        pro = new Properties();
        try {//参数配置
            pro.load(new FileInputStream("D:\\db.properties"));
            jdbcDriver = pro.getProperty("jdbcDriver");
            jdbcUrl = pro.getProperty("jdbcUrl");
            userName = pro.getProperty("userName");
            password = pro.getProperty("password");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void getConnection(){  //和mysql 建立连接
        try {
            Class.forName(jdbcDriver);//加载驱动
            connection = DriverManager.getConnection(jdbcUrl,userName,password);//建立连接
            if(connection.isClosed()){
                System.out.println("连接建立失败");
            }
            System.out.println("连接建立成功");

            statement = connection.createStatement();//获取对象，对数据库中的表进行操作时使用的对象，所有操作数据库表的方法都在这个statement之下
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void selectTest(){
        String sql="select * from student";
        //通过statement对象将sql提交给mysql执行，访问student表
        try {
            ResultSet resultSet = statement.executeQuery(sql);//获取结果集
            //遍历结果集查看获取数据
            //此处next方法类似迭代器的next和hasNext的结合实现
            while(resultSet.next()){
                System.out.println("stu_id:"+resultSet.getString(1)+
                        "  name:"+resultSet.getString(2)+
                        "  age:"+resultSet.getString(3)+
                        "  sex:"+resultSet.getString(4));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void updateTest(){
        String sql="update table1 set age=20 where id=01";
        try {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void insertTest(){
        String sql="insert table1(id,age) values (02,31)";
        try {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void deleteTest(){
        String sql="delete from table1 where id=1";
        try {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void closeConnection(){
        try {
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        JdbcTest jdbcTest = new JdbcTest();
        jdbcTest.getConnection();
        jdbcTest.selectTest();
        jdbcTest.updateTest();
        jdbcTest.insertTest();
        jdbcTest.deleteTest();
        jdbcTest.closeConnection();
    }
}

注：关于execute、executeQuery、executeUpdate
如果sql语句对数据库中的信息进行查看使用executeQuery；如果对数据库中的信息造成修改使用executeUpdate，增insert，删delete；如果不造成修改使用execute。
（2）操作数据库的对象为PreparedStatement

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
public class JdbcPreparedTest {
    private String jdbcDriver;
    private String jdbcUrl;
    private String userName;
    private String password;
    private Properties pro;
    private Connection connection;

    public JdbcPreparedTest(){
        pro = new Properties();
        try {//参数配置
            pro.load(new FileInputStream("D:\\db.properties"));
            jdbcDriver = pro.getProperty("jdbcDriver");
            jdbcUrl = pro.getProperty("jdbcUrl");
            userName = pro.getProperty("userName");
            password = pro.getProperty("password");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void getConnection(){  //和mysql 建立连接
        try {
            Class.forName(jdbcDriver);//加载驱动
            connection = DriverManager.getConnection(jdbcUrl,userName,password);//建立连接
            if(connection.isClosed()){
                System.out.println("连接建立失败");
            }
            System.out.println("连接建立成功");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public void selectTest(){
        String sql="select * from table1 where id>=?";
        PreparedStatement pre=null;
        try {
            pre=connection.prepareStatement(sql);
            pre.setInt(1,3);//查看id大于等于3的
            ResultSet resultSet = pre.executeQuery();//获取结果集
            //遍历结果集查看获取数据
            //此处next方法类似迭代器的next和hasNext的结合实现
            while(resultSet.next()) {
                System.out.println("id:" + resultSet.getString(1) +
                        "  age:" + resultSet.getString(2)); }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void deleteTest(){
        String sql="delete from table1 where id=3";
        PreparedStatement pre=null;
        try {
            pre=connection.prepareStatement(sql);
            //将无参的语句提交给PreparedStatement
            pre.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if(pre!=null){
                try {
                    pre.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public void insertTest(){
        String sql="insert table1 values(?,?)";
        PreparedStatement pre=null;
        try {
            connection.commit();//commit操作
            connection.rollback();//rollback操作
            Savepoint p1 = connection.setSavepoint("p1");//设置保存点
            connection.rollback(p1);//退回至保存点
            connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);//设置事务的隔离级别

            pre=connection.prepareStatement(sql);
            //将无参的语句提交给PreparedStatement
            pre.setInt(1,3);//插入学号3，年龄56
            pre.setInt(2,56);
            pre.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if(pre!=null){
                try {
                    pre.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    //优化后的插入方法，以提高在插入大量数据时的性能
    public void insert1(){
        PreparedStatement pst =null;
        try {
            String sql = new String("insert into table1 (id,age) values (?,?)");
            pst=connection.prepareStatement(sql);
            System.out.println("开始插入");
            for (int i = 1; i <= 10; i++) {//插入10条进行测试
                System.out.println("插入第"+i+"条");
                for (int j = 1; j <2; j++) {
                    pst.setInt(j, i);//学号
                    pst.setInt(j+1, (int) (Math.random()* 100 + 1));//年龄
                }
                pst.executeUpdate();
            }
            System.out.println("插入完成。");
            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void closeConnection(){
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        JdbcPreparedTest jdbcPreparedTest=new JdbcPreparedTest();
        jdbcPreparedTest.getConnection();
        jdbcPreparedTest.insertTest();
        jdbcPreparedTest.deleteTest();
        jdbcPreparedTest.selectTest();
        jdbcPreparedTest.closeConnection();
    }
}

（3）对比
①在执行多次相同结构的sql语句时适合使用PreparedStatement，执行单次时可使用Statement。因为Statement提交执行的是带参数的sql，可以直接得到结果，而PreparedStatement先提交一个无参的sql，再设置参数然后执行sql。
②在sql注入异常方面（利用非法的SQL拼接达到入侵数据库的目的，主要是由于程序对用户输入的数据没有进行严格的过滤，导致非法的数据库SQL操作语句的执行）

//使用Statement
public void logIn(String name,String password){
        String sql="select * from table2 where name ='"+name+"' and password= '"+password+"' ";
        System.out.println(sql);
        try {
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            if(resultSet.next()){
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //使用PreparedStatement
    public void logIn1(String name,String password){
        String sql="select * from table2 where name=? and password=?";
        PreparedStatement pre=null;

        try {
            pre = connection.prepareStatement(sql);
            pre.setString(1,name);
            pre.setString(2,password);
            System.out.println(pre);
            ResultSet resultSet = pre.executeQuery();
            if(resultSet.next()){
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

此时在主函数中分别调用这两个方法：

jdbcPreparedTest.logIn("xiaoli","12345 'or' 1=1");
jdbcPreparedTest.logIn1("xiaoli","12345 'or' 1=1");

结果：
在这里插入图片描述
可以看出，PreparedStatement能够有效避免sql注入异常，而Statement无法避免。
三、使用JDBC操作事务
例：事务回滚

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

public class TranTest {
    private String jdbcDriver;
    private String jdbcUrl;
    private String userName;
    private String password;
    private Properties pro;
    private Connection connection;

    public TranTest(){
        pro = new Properties();
        try {//参数配置
            pro.load(new FileInputStream("D:\\db.properties"));
            jdbcDriver = pro.getProperty("jdbcDriver");
            jdbcUrl = pro.getProperty("jdbcUrl");
            userName = pro.getProperty("userName");
            password = pro.getProperty("password");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void getConnection(){  //和mysql 建立连接
        try {
            Class.forName(jdbcDriver);//加载驱动
            connection = DriverManager.getConnection(jdbcUrl,userName,password);//建立连接
            if(connection.isClosed()){
                System.out.println("连接建立失败");
            }
            System.out.println("连接建立成功");
            connection.setAutoCommit(false);
            connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void selectData(PreparedStatement pre){
        try {
            ResultSet resultSet = pre.executeQuery();
            while(resultSet.next()) {
                System.out.println("name:" + resultSet.getString(1) +
                        "  password:" + resultSet.getString(2)); }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void insertData(PreparedStatement pre){
        try {
            for (int i = 1; i <= 2; i++) {
                for (int j = 1; j <2; j++) {
                    pre.setString(j, "testUser"+i);
                    pre.setString(j+1, "xxxyyy");
                }
                pre.executeUpdate();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(pre!=null){
                try {
                    pre.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public void rollBackTest(){
        //查看table2数据共三条，用preparedStatement提交两条数据
        //再次查看表中数据
        //执行rollback
        String select ="select * from table2";//查询命令
        String sql="insert table2 values(?,?)";//插入命令
        try {
            PreparedStatement selectPre=connection.prepareStatement(select);
            System.out.println("第一次查询（共三条）：");
            selectData(selectPre);
            PreparedStatement pre=connection.prepareStatement(sql);
            System.out.println("\n"+"插入数据完成。");
            insertData(pre);
            connection.setSavepoint();
            System.out.println("\n"+"设置保存点完成。");
            System.out.println("\n"+"第二次查询（五条）：");
            selectData(selectPre);
            System.out.println("\n"+"执行rollback。");
            connection.rollback();
            System.out.println("\n"+"第三次查询（三条）：");
            selectData(selectPre);
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TranTest tranTest=new TranTest();
        tranTest.getConnection();
        tranTest.rollBackTest();
    }
}

结果：
在这里插入图片描述

cloudonut_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mysql-connector-cj-8.0.32.jar JDBC驱动 解压即用
03-09
mysql-connector-j 是 MySQL 官方提供的一个 JDBC 驱动，用于在 Java 应用程序中连接和操作 MySQL 数据库。它是开源的，使用它可以方便地在 Java 代码中操作 MySQL 数据库。mysql-connector-j 以 jar 包的形式提供，...
mysql-connector-java(jdbc)
08-09
下载资源之后将资源解压开，然后导入eclipse中就可以了。如果是web项目注意还要将资源放在WEB-INF目录下的lib文件夹下面
JDBC-MySql超时
I want to know a little more.
07-16 409
前言 本文讨论的源码是基于connectorJ 5.1.37，最新版的jar包是5.1.38，两者对于该处的逻辑并无差别。 connectorJ mysql官网下载地址：点击打开链接（http://dev.mysql.com/downloads/connector/j/） 一、JDBC API支持 java.sql.Statement中定义的查询超时规范： /** * Sets the number of seconds the driver will wait fo...
JDBC原理&浅析HIVE-JDBC
梦境迷离
07-02 3046
目录 {:toc} 什么是JDBC？ JDBC是Java DataBase Connectivity的缩写，它是Java程序访问数据库的标准接口。Java8 JDBC API 使用Java程序访问数据库时，Java代码并不是直接通过TCP连接去访问数据库，而是通过JDBC接口来访问，而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。 例如，我们在Java代码中如果要访问MySQL，那么必须编写代码操作JDBC接口。注意到JDBC接口是Java标准库自带的，所以可以直接编译。而具体的JDBC驱动是.
jdbc连接mysql原理_JDBC 原理浅析
weixin_35104141的博客
01-27 548
JDBC 原理浅析一.本节目的:了解JDBC的概念及工作原理写在详解前对JAVA基础知识的回顾:JAVA接口:是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。通过接口可以实现不相关的类的相同行为.通过接口可以指明多个类需要实现的方法.通过接口可以了解对象的交互方法而不需要了解对象所对应...
mysql--分库&分表&分区浅析
2401_83707780的博客
04-23 735
一、简介MySQL分库分表是一种常用的数据库架构优化方法，特别适用于数据量大、访问压力高的情况。通过将数据分布到多个数据库或表中，可以提高系统的可扩展性、性能和管理效率。以下是MySQL分库分表的一些关键应用场景和考虑因素。
浅析JDBC使用步骤及主要对象
qq_20581853的博客
10-18 371
浅析JDBC使用步骤及主要对象 一、JDBC是什么 JDBC（Java Database Connectivity，简称JDBC）即Java数据库连接（JDBC）API，是Java编程语言与各种数据库、SQL数据库和其他表格数据源（如电子表格或平面文件）之间独立于数据库的连接的行业标准。JDBC API为基于SQL的数据库访问提供了一个调用级API。 二、为什么使用JDBC JDBC技术允许您使用Java编程语言为需要访问企业数据的应用程序开发“一次编写，随时随地运行”的功能。使用支持JDBC技术的驱动程序
linux mysql jdbc 慢_浅析MySQL JDBC连接配置上的两个误区
weixin_29663061的博客
02-01 176
相信使用MySQL的同学都配置过它的JDBC驱动，多数人会直接从哪里贴一段URL过来，然后稍作修改就上去了，对应的连接池配置也是一样的，很少有人会去细想这每一个参数都是什么含义。今天我们就来聊两个比较常见的配置——是否要开启autoReconnect和是否缓存PreparedStatement。一、autoReconnect=true真的好用么？笔者看到过很多MySQL的URL里都是这样写的，复制...
MySQL JDBC StreamResult通信原理浅析
热门推荐
xieyuooo的专栏
10-17 1万+
好几年没写技术博客了，今天写一个小的技术点给大家分享，关于MySQL JDBC StreamResult的原理分享，难度不大，就当程序员的闲聊。 如果使用MySQL JDBC读取过比较大的数据（例如超过1GB），应该清楚在读取的时候，很可能会Java堆内存溢出，我们的解决方案通常是使用useCursorFetch读取或Stream读取来处理。使用Stream读取的方式通常的操作方式是在执行SQL...
mysql jdbc驱动 许可_JDBC的驱动注册浅析
weixin_39609457的博客
02-01 156
JDBC驱动类是一个接口——java.sql.Driver。这个接口是给实现JDBC接口的各个数据库实现的。Class.forName(JDBC_DRIVER);它起到的作用就是加载具体实现的jar包中实现Driver的具体子类，类加载的过程中会调用static方法块的代码，数据库驱动的注册就在该static块中。如果不用Class的forName方法，直接实例化Driver对象也行，实例化自然也...
浅析MySQL JDBC连接配置上的两个误区
qq_34350584的博客
08-16 1280
相信使用MySQL的同学都配置过它的JDBC驱动，多数人会直接从哪里贴一段URL过来，然后稍作修改就上去了，对应的连接池配置也是一样的，很少有人会去细想这每一个参数都是什么含义。今天我们就来聊两个比较常见的配置——是否要开启autoReconnect和是否缓存PreparedStatement。 一、autoReconnect=true真的好用么？ 笔者看到过很多MySQL的URL里都是这样写的，复制过来改改IP、端口和库名就能用了： jdbc:mysql://xxx.xxx.xxx.xxx:3306
jdbc-mysql-connector-j-8.0.31.jar jdbc-sqljdbc41.jar
02-08
Jmeter接口自动化，mysql和sqlserver的jdbc驱动，下载后解压，放入jmeter的lib目录即可；
aws-mysql-jdbc：适用于MySQL的Amazon Web Services（AWS）JDBC驱动程序是一种驱动程序，使应用程序可以充分利用群集MySQL数据库的功能
02-08
适用于MySQL的Amazon Web Services（AWS）JDBC驱动程序适用于MySQL的Amazon Web Services（AWS）JDBC驱动程序是一种驱动程序，使应用程序可以充分利用群集MySQL数据库的功能。 它基于，并且可以用作该插件的兼容并且...
mysql-jdbc
12-14
mysql-connection，jdbc桥连接，用于eclipse等软件，巴拉巴拉
专属编程笔记
最新发布
u014397365的博客
06-01 986
在软件开发中，Utils（或Utilities）目录通常用于存放一些。这些工具类或函数为整个应用程序或多个模块提供便利的功能支持，使得代码更加模块化、易于维护和重用。UtilsUtils目录的设计目的在于避免代码重复，并确保在整个项目中以一致的方式处理共通任务。这样做可以提高开发效率，降低维护成本，并确保代码的整洁性和可读性。
如何mysql数据导入到mongdb
codemami的博客
05-30 1528
由于MySQL和MongoDB的数据模型不同（例如，MySQL使用关系模型，而MongoDB使用文档模型），你可能需要转换数据的格式。使用MongoDB驱动程序：你也可以使用MongoDB的官方驱动程序（如Python的pymongo）来编写脚本，将数据直接插入到MongoDB中。注意：如果你的JSON文件包含多个文档，并且它们不是作为数组的一部分（即每个文档都在其自己的行上），则需要使用--jsonArray选项。手动转换：对于小型数据集，你可以手动编辑SQL或CSV文件，将其转换为JSON格式。
oracle中的INTERVAL函数学习总结
weixin_42821740的博客
05-30 543
简单学懂interval函数
行列视（RCV）能否在指定时间生成报表数据？
2401_83701843的博客
05-30 185
需要注意的是，要实现指定时间生成报表数据的功能，用户需要确保行列视（RCV）系统已经正确配置并连接了相应的数据源，同时还需要根据实际需求进行报表格式和计算逻辑的设置。此外，系统的稳定性和性能也是影响报表生成的重要因素，用户需要确保系统能够正常运行并处理大量的数据。其次，关于指定时间生成报表数据的需求，用户可以通过行列视（RCV）的定时任务功能来实现。综上所述，行列视（RCV）具备在指定时间生成报表数据的能力，但具体实现方式需要根据系统的配置和使用需求来确定。
mysql-connector-java和spring-boot-start-jdbc的区别
05-30
mysql-connector-java和spring-boot-start-jdbc都是用于在Java应用程序中连接和操作MySQL数据库的库，但它们的作用不同。 mysql-connector-java是MySQL官方提供的Java连接器，它提供了一组Java类和方法，可以通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值