JDBC基本内容

小熊佩萁

已于 2022-10-13 20:14:19 修改

阅读量795

点赞数 1

分类专栏： JDBC 文章标签：数据库 java oracle

于 2022-10-12 23:50:55 首次发布

本文链接：https://blog.csdn.net/weixin_51470901/article/details/127290942

版权

JDBC 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.为什么学JDBC？什么是JDBC？

JDBC：就是使用Java语言操作关系型数据库的一套API，全称：( Java DataBase Connectivity ) Java 数据库连接
我们开发的同一套Java代码是无法操作不同的关系型数据库，因为每一个关系型数据库的底层实现细节都不一样。如果这样，问题就很大了，在公司中可以在开发阶段使用的是MySQL数据库，而上线时公司最终选用oracle数据库，我们就需要对代码进行大批量修改，这显然并不是我们想看到的。我们要做到的是同一套Java代码操作不同的关系型数据库，而此时sun公司就指定了一套标准接口（JDBC），JDBC中定义了所有操作关系型数据库的规则。众所周知接口是无法直接使用的，我们需要使用接口的实现类，而这套实现类（称之为：驱动）就由各自的数据库厂商给出。

使用java语言操作数据库，我们可以用这张图帮助理解:
在这里插入图片描述
JDBC本质:

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

JDBC有的好处:

各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
可随时替换底层数据库，访问数据库的Java代码基本不变

以后编写操作数据库的代码只需要面向JDBC（接口），操作哪儿个关系型数据库就需要导入该数据库的驱动包，如需要操作MySQL数据库，就需要在项目中导入MySQL数据库的驱动包。如下图就是MySQL驱动包：
在这里插入图片描述

1.下载jar包

驱动包我们可以自己在网上下载到，怎么下载?参考这位大佬的博客，讲的非常清晰，保姆级，下载jav包
下载好了jav怎么用？不导入jav包JDBC的所有借口都是不能用的。

2.导入jar包

第一步：

创建一个空项目
定义项目的名称并指定位置
对项目进行设置，JDK版本，编译版本
创建模块，指定模块的名称和位置

第二步：导入驱动包(jav包)

导入后鼠标放在这个jav包上右键找到Add as Library…然后点击这个选项，一直点确定，第二次确定你会看到这个界面在这里插入图片描述

Global Library ：全局有效
Project Library : 项目有效
Module Library ：模块有效
最后点ok就好啦
再同样右键鼠标，你会发现没有Add as Library…这个选项了，这说明你导入驱动成功了

2.JDBC API的一些解释和演示

1.Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。

执行DDL、DML语句
executeUpdate 比如 insert delete update这些sql语句
执行DQL语句
executeQuery 一些查询sql语句，比如像select

1.executeUpdate

import java.sql.Statement;

public class jdbcDemo {
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取连接 
        //语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…
        //如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对
        //配置 useSSL=false 参数，禁用安全连接方式，解决警告提示
        //如果不加useSSL=false 参数，则每次运行代码都会有一行红色警告，大家可以自己加上然后去掉对比前后效果
        String url = "jdbc:mysql://127.0.0.1:3306/db6?useSSL=false";
        String username = "root";
        String password = "你的数据库密码";
        //Connection:获取执行 SQL 的对象
        Connection conn = DriverManager.getConnection(url, username, password);
        //定义要执行的sql语句
        String sql1 = "update account set money = money-500 where id = '1'";
        String sql2 = "update account set money = money +500 where id = 2";

        //获取执行sql的对象
        Statement statement = conn.createStatement();
        try {
            //设置为不自动提交，mysql默认自动提交
            conn.setAutoCommit(false);
            //执行sql
            int count1 = statement.executeUpdate(sql1);
            //System.out.println(1/0);
            int count2 = statement.executeUpdate(sql2);
            //通过看数据库中受影响的行数来看是否执行成功
            System.out.print("受影响的行:" + count1 + " ");
            System.out.print("受影响的行:" + count2);
            conn.commit();//代码执行到此说明没有错误
        } catch (SQLException throwables) {
            //如果有错误，就会回滚
            throwables.printStackTrace();
            conn.rollback();//如果有错误，就回滚事务
        }
        //释放资源
        statement.close();
        conn.close();
    }
}

注意:以后开发很少使用java代码操作DDL语句(我也是了解到，本人还是学生，具体是不是工作之后或许就有更深刻的体会吧~)

2.executeQuery

该方法涉及到了 ResultSet 对象
ResultSet（结果集对象）作用：我的理解是它相当于把你所查找的数据库提取出来然后把这个结果封装成一个对象，你如果要用这个对象你就拿出来用，并且这个对象里面包含了你想要的一些数据，通过调用一些方法来拿到数据，
比如这些方法；
boolean next()

将光标从当前位置向前移动一行就是说如果你光标在第二行，它会移到第一行，进而来判断下一行是否有数据可以让我们去得到
判断当前行是否为有效行这个特性我们可以用于 while()循环放在里面如果为真就往下遍历数据并取出，如果不为真就退出
- true ：有效行，当前行有数据
false ：无效行，当前行没有数据
具体代码

import java.sql.*;
import java.util.ArrayList;

public class Sql {
    public static void main(String[] args) throws Exception {
        //通过创建一个账户类来接收
        ArrayList<Account> accounts = new ArrayList<>();
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/db6?useSSL=false";
        String username = "root";
        String password = "你的数据库密码";
        Connection conn = DriverManager.getConnection(url, username, password);

        //定义sql
        String name = "张三";
        //在这里我们要讲一下sql注入的问题，SQL注入就是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。如果直接使用statement执行对象，就有可能发生sql注入的危险
        String id = "' or '1' = '1";
        //String name = ""+"";
        //定义要执行的sql语句
        String sql1 = "select * from account where name = '"+name+"'and id='"+id+"'";
        System.out.println(sql1);
        //select * from account where name = '张三'and id='' or '1' = '1'

        //获取Statement
        Statement statement = conn.createStatement();
        //执行sql
        ResultSet resultSet = statement.executeQuery(sql1);
        while (resultSet.next()) {
            Account account = new Account(id,name);
            accounts.add(account);
        }
        System.out.println(accounts);
        //释放资源
        resultSet.close();
        statement.close();
        conn.close();
    }
}

public class Account {
    private String id;
    private String money;

    public Account() {
    }

    public Account(String id, String money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getMoney() {
        return money;
    }

    public void setMoney(String money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id='" + id + '\'' +
                ", money='" + money + '\'' +
                '}';
    }
}

运行结果：在这里插入图片描述
我们会发现我们并没有输入张三的id，可是最终也查询到了张三的一些信息， password = '‘不管是否满足，而or后面的’1’ = ‘1’` 是始终满足的，最终条件是成立的，就可以正常的进行登陆了。这对于数据库信息的安全来说，是很不严谨的，所以要严防sql注入。
怎么防止sql注入？其实statement对象，它执行的是一个已经编译好的sql语句，而SQL注入就是通过操作输入来修改事先定义好的SQL语句，我们只要先不编译好sql语句不就可以防止sql注入了嘛，所以就有了PreparedStatement 用它来代替statement
。
PreparedStatement作用和好处：

预编译SQL语句并执行：预防SQL注入问题
SQL语句中的参数值，使用？占位符替代
预编译SQL，性能更高
防止SQL注入：将敏感字符进行转义

检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果我们只是重新设置参数，那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。

接下来我们通过查询日志来看一下原理。

开启预编译功能
在代码中编写url时需要加上以下参数。而我们之前根本就没有开启预编译功能，只是解决了SQL注入漏洞。

useServerPrepStmts=true

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;

public class jdbcDemo1 {
    public static void main(String[] args) throws Exception {
        //通过创建一个账户类来接收
        ArrayList<Account> accounts = new ArrayList<>();
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/db6?useSSL=false&useServerPrepStmts=true";
        String username = "root";
        String password = "你的数据库密码";
        Connection conn = DriverManager.getConnection(url, username, password);

        String id = "1";
        String money = "1000";
        //String name = ""+"";
        //定义要执行的sql语句
        //String sql1 = "select * from account where username = '"+id+"'and password='"+money+"'";
        String sql1 = "select * from account where id = ? and money = ?";

        //获取PreparedStatement 通过conn对象获取，并传入对应的sql语句
        PreparedStatement preparedStatement = conn.prepareStatement(sql1);
        Thread.sleep(3000);
        //第一个位置
        preparedStatement.setString(1,id);
        //第二个位置
        preparedStatement.setString(2,money);
        //执行sql
        ResultSet resultSet ==preparedStatement.executeQuery();
        while (resultSet.next()) {
            Account account = new Account(id, money);
            accounts.add(account);
        }
        System.out.println(accounts);
        //释放资源
        resultSet.close();
        preparedStatement.close();
        conn.close();
    }
}

通过日志看preparedStatement的预编译原理

配置MySQL执行日志（重启mysql服务后生效）

在mysql配置文件（my.ini）中添加如下配置

log-output=FILE
general-log=1
general_log_file="D:\mysql.log"
slow-query-log=1
slow_query_log_file="D:\mysql_slow.log"
long_query_time=2

重新运行mysql服务后，D盘目录下会有这两个文件，这就是日志文件，可以看到mysql的语句的执行原理：
在这里插入图片描述

第四行中的 Prepare 是对SQL语句进行预编译
第五行执行了SQL语句

在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查，编译（这些步骤很耗时）
执行时就不用再进行这些步骤了，速度更快
如果sql模板一样，则只需要进行一次检查、编译

3.数据库连接池

数据库连接池是个容器，负责分配、管理数据库连接(Connection)
它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个
好处：
资源重用
提升系统响应速度
避免数据库连接遗漏
之前我们代码中使用连接都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。而数据库使用了数据库连接池后，就能达到Connection对象的复用。如下图：

连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度。
常见的数据库连接池：

DBCP
C3P0
Druid
我们现在使用更多的是Druid，它的性能比其他两个会好一些。

Driud使用

导入jar包 druid-1.1.12.jar
定义配置文件
加载配置文件
获取数据库连接池对象
获取连接
导入jar包和之前导入mysql jar包一样，步骤都一样
导入jar包后写.proerties配置文件

将下面的内容写入上面创建的配置文件中：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db1?useSSL=false&useServerPrepStmts=true
username=root
password=你的数据库密码
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

下面的测试是否使用成功

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.alibaba.druid.pool.xa.DruidXADataSource;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;

public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3. 加载配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\jdbc-demo\\jdbc-demo\\src\\druid.properties"));//这是配置文件的绝对路径
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        //5. 获取数据库连接 Connection
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

结果：
在这里插入图片描述
这样的显示就是成功连接一个了。

4.JDBC练习

下面是我管我老师要的练习题分享出来，其中就用到了数据库连接池
完成商品品牌数据的增删改查操作

查询：查询所有数据
添加：添加品牌
修改：根据id修改
删除：根据id删除
准备工作:

create table tb_brand (
    -- id 主键
    id int primary key auto_increment,
    -- 品牌名称
    brand_name varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered int,
    -- 描述信息
    description varchar(100),
    -- 状态：0：禁用  1：启用
    status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);

===========================================

/**
 * 品牌
 * alt + 鼠标左键：整列编辑
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
public class Brand {
    // id 主键
    private Integer id;
    // 品牌名称
    private String brandName;
    // 企业名称
    private String companyName;
    // 排序字段
    private Integer ordered;
    // 描述信息
    private String description;
    // 状态：0：禁用  1：启用
    private Integer status;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public Integer getOrdered() {
        return ordered;
    }

    public void setOrdered(Integer ordered) {
        this.ordered = ordered;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

1.查询所有

 /**
   * 查询所有
   * 1. SQL：select * from tb_brand;
   * 2. 参数：不需要
   * 3. 结果：List<Brand>
   */

@Test
public void testSelectAll() throws Exception {
    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = "select * from tb_brand;";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    //5. 执行SQL
    ResultSet rs = pstmt.executeQuery();
    //6. 处理结果 List<Brand> 封装Brand对象，装载List集合
    Brand brand = null;
    List<Brand> brands = new ArrayList<>();
    while (rs.next()){
        //获取数据
        int id = rs.getInt("id");
        String brandName = rs.getString("brand_name");
        String companyName = rs.getString("company_name");
        int ordered = rs.getInt("ordered");
        String description = rs.getString("description");
        int status = rs.getInt("status");
        //封装Brand对象
        brand = new Brand();
        brand.setId(id);
        brand.setBrandName(brandName);
        brand.setCompanyName(companyName);
        brand.setOrdered(ordered);
        brand.setDescription(description);
        brand.setStatus(status);

        //装载集合
        brands.add(brand);
    }
    System.out.println(brands);
    //7. 释放资源
    rs.close();
    pstmt.close();
    conn.close();
}

2. 添加数据

/**
  * 添加
  * 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
  * 2. 参数：需要，除了id之外的所有参数信息
  * 3. 结果：boolean
  */
@Test
public void testAdd() throws Exception {
    // 接收页面提交的参数
    String brandName = "香飘飘";
    String companyName = "香飘飘";
    int ordered = 1;
    String description = "绕地球一圈";
    int status = 1;

    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);

    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

3.修改数据

/**
  * 修改
  * 1. SQL：

     update tb_brand
         set brand_name  = ?,
         company_name= ?,
         ordered     = ?,
         description = ?,
         status      = ?
     where id = ?

   * 2. 参数：需要，所有数据
   * 3. 结果：boolean
   */

@Test
public void testUpdate() throws Exception {
    // 接收页面提交的参数
    String brandName = "香飘飘";
    String companyName = "香飘飘";
    int ordered = 1000;
    String description = "绕地球三圈";
    int status = 1;
    int id = 4;

    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = " update tb_brand\n" +
        "         set brand_name  = ?,\n" +
        "         company_name= ?,\n" +
        "         ordered     = ?,\n" +
        "         description = ?,\n" +
        "         status      = ?\n" +
        "     where id = ?";

    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    //4. 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);
    pstmt.setInt(6,id);

    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

4.删除数据

/**
  * 删除
  * 1. SQL：
            delete from tb_brand where id = ?
  * 2. 参数：需要，id
  * 3. 结果：boolean
  */
@Test
public void testDeleteById() throws Exception {
    // 接收页面提交的参数
    int id = 4;
    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = " delete from tb_brand where id = ?";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    pstmt.setInt(1,id);
    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}