JDBC学习笔记

前言：

JDBC是什么？

JDBC（Java Database Connectivity）是Java编程语言中用于连接和操作数据库的API（应用程序编程接口）。它提供了一组标准的接口，使Java应用程序能够与各种数据库（如MySQL、Oracle、SQL Server等）进行交互。

一.JDBC简介(面向接口编程)

1.简介

jdbc就是一套可以适配关系型数据库的规则，可以用来操作MySQL，Oracle，DB2等等，也就是一套接口，通过这些接口就可以操作不同的数据库，不同的数据库都有自己对应于JDBC的实现类（也就是我们说的驱动）。

2.本质：

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

这样做的优点就是,我们可以使用同一套JDBC去操作不同的数据库

3.好处

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

3.基本步骤

• 注册驱动
• 获取连接对象
• 定义SQL
• 获取执行SQL的对象
• 执行SQL
• 处理结果
• 释放资源

二.快速入门

在此之前 我们需要下载安装好MySQL和Navicat

MySQL

MySQL社区版下载教程

Navicat

Navicat下载教学

1.创建工程,导入驱动jar包

直接把驱动复制到lib上去

然后右键点击添加到库

点击确定即可

2.注册驱动

Class.forName("com.mysql.jdbc.Driver"); //forName用来将一个类加载进内存

3.获取连接

Connection conn = DriverManager.getConnection(url,username,password);

4.定义SQl语句

String sql = "update...";

5.获取执行SQL对象

Statement stmt = conn.createStatement();

6.执行SQL

其实就是SQL语句 发送给MySQL数据库 让MySQL数据库来执行

stmt.executeUpdate(sql);

7.处理返回结果

执行完之后,MySQL数据库会返回一个结果,那么我们就需要来处理这个结果

8.释放资源

完成操作后,我们需要释放资源

9.操作代码如下

package JavaProjectExer;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.Statement;

/*
JDBC快速入门
*/
public class JDBCDemo {
    public static void main(String[] args) throws Exception{
        //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");//使用forName把驱动类名加载进来
        //2.获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/car count";//固定写法,只有后面的car count 是自己的数据库名字
        String username = "root";//MySQL的用户名
        String passeord = "123456";//MySQL的密码
        Connection conn = DriverManager.getConnection(url,username,passeord);//使用DriverManager.getConnection传入三个对应的参数
        //定义sql语句
        String sql = "UPDATE `car-test` SET Cid = '赣B888888' WHERE Cid = '赣B111111';";//把对数据库操作的sql语句写进去

        //4.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();//使用Statement获取sql执行的对象

        //5.执行sql
        int  count = stmt.executeUpdate(sql);//执行完之后会返回一个结果,这个结果就是受影响的行数

        //6.处理结果
        System.out.println(count);//处理结果很简单,打印count就可以

        //7.释放资源
        stmt.close();//先释放stmt
        conn.close();//然后再释放conn
    }
}

 把赣B111111 改成了 赣B888888

 输出的结果count = 1,因为我们就改了一行数据

三.JDBC API详解

1.DriverManager(驱动管理类)

1.1注册驱动

在上面的代码中,我们使用forName把Driver类加载进内存,没有使用DriverManager,为什么呢?

我们点开Driver源码进去看就知道了, Ctrl +鼠标左键,在静态代码块中使用了DriverManager,在加载Driver时会自动执行,执行完之后DriverManager就把驱动注册上了

有一点要注意!!!

我们把

Class.forName("com.mysql.jdbc.Driver");//使用forName把驱动类名加载进来

这一行注释掉也没有关系,具体原因可自行了解.

1.2获取数据库连接

static Connection 
getConnection(String url,String user,String password)

 重点说一下这个url(即连接路径 ):

语法:jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2...(固定的书写格式)

示例:jdbc:mysql://127.0.0.1:3306/car count

细节1:如果连接的是本机的mysql服务器,并且mysql服务器默认端口是3306,则url可以简写成:jdbc:mysql://数据库名称

细节2:配置useSSL = flase 参数,禁用安全连接方式,解决警告提示(需要很复杂的配置,也会降低使用效率)

代码如下

String url = "jdbc:mysql:///car count?useSSL = flase";

2.Connection(数据库连接对象)

2.1获取执行SQL的对象

• 普通执行SQL对象

Statement createStatement()

•  预编译SQL的执行SQL对象:防止SQL注

PreparedSatement prepareStatement(sql)

•  执行存储过程的对象

CallableStatement prepareCall(sql)

2.2管理事务

• MySQL事务管理

开启事务:BEGIN;/START TRANSACTION;

提交事务:COMMIT;

回滚事务:ROLLBACK;

MySQL默认自动提交事务

• JDBC事务管理:Connection接口中定义了三个对应的方法

开启事务:setAutoConnection(boolean autoCommit):ture为自动提交事务:false为手动提交事务,即为开启事务

提交事务:commit()

回滚事务:rollback()

3.Statement

• 执行SQl语句

DDL:对表和库的增删改查操作

DML:对数据的增删改查操作

DQL:对数据的查询操作

int executeUpdate(sql)://执行DML,DDL语句,返回值:1.DML语句影响的行数 2.DDL语句执行后,执行成功之后也可能返回0

ResultSet  executeQuery(sql)://执行DQL语句 返回值:RessultSet结果及对象

 代码如下

package JavaProjectExer;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

/*
JDBC快速入门
*/
public class JDBCDemo2 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try {
            // 1. 注册驱动
            Class.forName("com.mysql.cj.jdbc.Driver"); // 使用forName把驱动类名加载进来

            // 2. 获取连接
            String url = "jdbc:mysql://127.0.0.1:3306/car-count1?useSSL=false"; // 连接到 MySQL 服务器，不指定数据库
            String username = "root"; // MySQL 的用户名
            String password = "1234"; // MySQL 的密码
            conn = DriverManager.getConnection(url, username, password); // 使用 DriverManager.getConnection 传入三个对应的参数

            // 定义 SQL 语句
            String sql = "CREATE DATABASE `car-count2`"; // 使用反引号包裹数据库名

            // 4. 获取执行 SQL 的对象 Statement
            stmt = conn.createStatement(); // 使用 Statement 获取 SQL 执行的对象

            // 5. 执行 SQL
            int count = stmt.executeUpdate(sql); // 执行创建数据库的操作

            // 6. 处理结果
            //System.out.println("数据库创建成功");
            if(count > 0){
                System.out.println("创建成功");
            }else{
                System.out.println("创建失败");
            }

        } catch (Exception e) {
            // 处理异常
            e.printStackTrace();
        } finally {
            // 7. 释放资源
            try {
                if (stmt != null) stmt.close(); // 先释放 stmt
                if (conn != null) conn.close(); // 然后再释放 conn
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

4.ResultSet(结果集对象)

4.1封装了DQL查询语句的结果

ResultSet stmt.executeQuery(sql)://执行DQL语句,返回ResultSet对象

获取查询结果 有两种操作
第一种:传递行
boolean next():
1.将光标(sql游标(类似于java中的迭代器))从当前位置向前移动一行
2.判断当前行是否有效行
返回值:
true:有效行,当前行有数据
false:无效行,当前行没有数据

第二种:传递列
xxx getxxx(参数) :获取数据
xxx :数据类型:  如:int getInt(参数) ; String getString(参数)
参数:
int : 列的序号,从1开始
String : 列的名称
 

 代码如下

package JavaProjectExer;

import pojo.Account;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/*
JDBC API 查询account账户表中的数据,封装为Account对象中,并且储存到ArrayList集合中
1.定义实体类 Account
2.查询数据, 并且封装到Account对象中
3.将Account对象存储到ArrayList集合中
*/

public class JDBCDemo4 {
    public static void main(String[] args) throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver"); // 使用forName把驱动类名加载进来

        // 2. 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/car-count1"; // 连接到数据库car-count1
        String username = "root"; // MySQL的用户名
        String password = "1234"; // MySQL的密码
        Connection conn = DriverManager.getConnection(url, username, password); // 获取数据库连接

        // 3. 定义SQL
        String sql = "SELECT * FROM `car-test`"; // 使用反引号包裹表名

        // 4. 获取statement对象
        Statement stmt = conn.createStatement();

        // 5. 执行SQL
        ResultSet rs = stmt.executeQuery(sql);

        // 创建集合
        List<Account> list = new ArrayList<>();

        // 6. 处理结果,遍历rs中的所有数据
        while (rs.next()) {
            Account account = new Account();
            // 6.2 获取数据  getXxx()
            int Cnumber = rs.getInt("Cnumber");
            String Cid = rs.getString("Cid");
            float Ccost = rs.getFloat("Ccost");

            // 赋值给 Account 对象
            account.setCnumber(Cnumber); // 修正拼写错误
            account.setCid(Cid);
            account.setCcost(Ccost);

            // 将对象添加到集合中
            list.add(account);
        }

        // 打印集合内容
        for (Account acc : list) {
            System.out.println(acc);
        }

        // 7. 释放资源, 一定要养成释放资源的习惯
        rs.close();
        stmt.close();
        conn.close();
    }
}

5.PreparedStatement

5.1注入示例

• PreparedStatement作用

预编译SQL语句并执行:预防SQL注入问题

• SQL注入

SQL注入是通过操作输入来修改事先定义好的SQL语句,用以达到执行代码对服务器进行攻击的方法

我们使用的是Statement 没有防止sql注入 所以使用这行登录也是可以成功的,随便一个用户名 和一个特定的字符串即可登陆成功

//sql注入演示
        String name = "asgfhds";
        String pwd  = "'or'1' = '1";

 

代码如下

package JavaProjectExer;

import pojo.Account;
import java.sql.*;

/*
用户登录
*/

public class JDBCDemo5 {
    public static void main(String[] args) throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver"); // 使用forName把驱动类名加载进来

        // 2. 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/car-count1"; // 连接到数据库car-count1
        String username = "root"; // MySQL的用户名
        String password = "1234"; // MySQL的密码
        Connection conn = DriverManager.getConnection(url, username, password); // 获取数据库连接

        // 接受用户输入的用户名和密码
        //String name = "Bob";
        //String pwd = "1234";


        //sql注入演示
        String name = "asgfhds";
        String pwd  = "'or'1' = '1";


        // 正确的SQL语句，去掉了全角字符，并正确格式化
        String sql = "SELECT * FROM `account` WHERE name = '" + name + "' AND pwd = '" + pwd + "'";

        // 获取stmt对象
        Statement stmt = conn.createStatement();

        // 执行sql
        ResultSet rs = stmt.executeQuery(sql);

        // 判断登录是否成功
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }

        // 释放资源
        rs.close();
        stmt.close();
        conn.close();
    }
}

5.2PreparedStatement详解

使用过程有三个步骤

•  获取PreparedStatement对象

String sql  = "select * from account where name ? and password  = ?";

//通过Connection对象获取,并传入对应的SQL语句中

PreparedStatement pstmt = conn.prepareStatement(sql);

• 设置参数

/*
PreparedStatement对象:setxxx(参数1,参数2,参数3...):给?赋值
xxx:数据类型;如setInt(参数1,参数2);
参数:
参数1:?的位置编号,从1开始
参数2:的值
*/

 使用?作为占位符 代替了Statement拼字符串

• 执行SQL

//executeUpdate();或者 executeQuery(); :不需要再传递sql

代码如下

package JavaProjectExer;

import pojo.Account;
import java.sql.*;

/*
PreparedStatement详解
*/

public class JDBCDemo6 {
    public static void main(String[] args) throws Exception {
        // 1. 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver"); // 使用forName把驱动类名加载进来

        // 2. 获取连接
        String url = "jdbc:mysql://127.0.0.1:3306/car-count1"; // 连接到数据库car-count1
        String username = "root"; // MySQL的用户名
        String password = "1234"; // MySQL的密码
        Connection conn = DriverManager.getConnection(url, username, password); // 获取数据库连接

        // 接受用户输入的用户名和密码
        //String name = "Bob";
        //String pwd = "1234";

        //sql注入演示
        String name = "asgfhds";
        String pwd  = "'or'1' = '1";

        //定义sql
        String sql = "SELECT * FROM `account` WHERE name = ? AND pwd = ?";

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

        //设置?的值
        pstmt.setString(1,name);
        pstmt.setString(2,pwd);

        //执行sql
        ResultSet rs = pstmt.executeQuery();



        // 判断登录是否成功
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }

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

 运行结果如下,显示登陆失败,即防止了sql注入

 5.3PreparedStatement原理

开启预编译功能 在url中加入useServerPrepStmts=ture

String url = "jdbc:mysql://127.0.0.1:3306/car-count1&useServerPrepStmts=ture";

四.数据库连接池

1.数据库连接池简介

 数据库连接池是一个容器，负责分配，管理数据库的连接

允许应用程序重复使用一个现有的数据库连接，而不是在重新建立一个

释放空间时间超过最大空闲时间的数据库连接来避免没有释放数据库连接而引起的数据库遗漏

好处：

• 资源复用
• 提升系统响应速度
• 避免数据库连接遗漏

2.数据库连接池的实现

标准接口DataSource

官方提供的数据库连接池标准接口，由第三方组织实现此接口

功能：获取连接

Connection getConnection（）

 常见的数据库连接池

• DBCP
• C3P0
• Druid（由阿里巴巴开源的数据库连接池项目，功能强大，性能优秀，是Java语言最好的数据库连接池之一）

3.Druid数据库连接池

Druid使用步骤

3.1导入jar包

 直接把jar包 拖到我们的lib文件包中，然后右键点击添加到库即可

3.2定义配置文件&加载配置文件

//3.加载配置文件（需要对应的需求来定制）
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));

3.3获取数据库连接池对象&获取连接

//5.获取数据库连接 Connection
        Connection connection=  dataSource.getConnection();

代码如下

package druid;


import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/*
Druid数据库连接池演示
 */
public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包

        //2.定义配置文件，直接把配置文件拖到我们的src文件包即可

        //3.加载配置文件（需要对应的需求来定制）
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));

        //4.获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //5.获取数据库连接 Connection
        Connection connection=  dataSource.getConnection();

        System.out.println(connection);

    }
}

五.练习测试

 完成商品品牌数据的增删改查操作

• 查询：查询所有的数据
• 添加：添加品牌
• 修改：根据id修改
• 删除：根据id删除

1.准备环境

 1.1数据库表 tb-brand

CREATE TABLE tb_brand (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 主键，自动递增
    brand_name VARCHAR(20),             -- 品牌名称
    company_name VARCHAR(50),           -- 企业名称
    ordered INT,                        -- 排序字段
    description VARCHAR(190),           -- 描述信息
    status INT                          -- 状态字段 (0: 禁用, 1: 启用)
);

INSERT INTO tb_brand (brand_name, company_name, ordered, description, status)
VALUES
    ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
    ('华为', '华为技术有限公司', 108, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
    ('小米', '小米科技有限公司', 50, 'Are you ok', 1);

SELECT * FROM tb_brand;

 创建好之后可以查询到这样的信息

1.2实体类Brand 

在我们的pojo中添加一个新的实体类 Brand

package pojo;

/*
品牌
alt+鼠标左键:整列编辑

在实体类中,基本数据类型建议使用其对应的包装类型!!!
 */

public class Brand {
    // 主键，自动递增  ctrl+r 替换文本
    private  String  brandName ;
    // 品牌名称
    private  String  companyName    ;
    // 企业名称
    private  Integer     ordered       ;
    // 排序字段
    private  String  description  ;
    // 描述信息
    private  Integer status;
    //状态: 0:禁用 1:启用
    private  Integer  id  ;

    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{" +
                "brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                ", id=" + id +
                '}';
    }
}

1.3测试用例

1.3.1查询操作

package example;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import pojo.Brand;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/*
对品牌的增删改查操作
操作流程 连接数据库->写SQL语句->把语句赋给PreparedStatement对象->执行SQL语句->返回执行语句->释放资源
 */
public class BrandTest2 {
    /*
    查询所有
    1.SQL语句
    2.参数
    3.结果:List<Brand>
     */

    @Test
    public void testSelectAll() throws Exception {
        // 1. 使用druid连接SQL
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));
        // 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
        // 获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        // 2. 定义SQL语句
        String sql = "SELECT * FROM tb_brand";

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

        // 4. 执行 SQL
        ResultSet rs = pstmt.executeQuery();

        // 创建一个 List 用于封装查询结果
        List<Brand> brandList = new ArrayList<>();

        // 6. 处理结果: List<Brand> 封装 Brand 对象, 装载 List 集合
        while (rs.next()) {
            Brand brand = new Brand();  // 这里初始化 Brand 对象
            // 获取数据
            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.setId(id);
            brand.setBrandName(brandName);
            brand.setCompanyName(companyName);
            brand.setOrdered(ordered);
            brand.setDescription(description);
            brand.setStatus(status);

            // 将封装好的 brand 对象添加到 List 集合中
            brandList.add(brand);
        }

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

        // 打印结果，确保查询到了数据
        System.out.println("品牌列表大小: " + brandList.size());
        for (Brand b : brandList) {
            System.out.println(b);
        }
    }

}

 1.3.2添加操作

添加功能:

• 编写sql语句
• 是否需要参数? 需要:除了id以外的所有数据
• 返回结果如何封装 ->boolea

package example;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import pojo.Brand;

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

/*
对品牌的增删改查操作
操作流程 连接数据库->写SQL语句->把语句赋给PreparedStatement对象->执行SQL语句->返回执行语句->释放资源
 */
public class BrandTest {
    /*
    添加操作
    1.SQL语句:INSERT INTO tb_brand(brand_name,company_name,ordered,description,status) VALUES(?,?,?,?,?);
    2.参数:
    3.结果:返回Boolean值
     */

    @Test
    public void testSelectAll() throws Exception {
        //接受页面提交的参数
        String brandName = "优乐美";
        String companyName = "优乐美";
        int ordered = 1;
        String description = "你是我的优乐美";
        int status = 1;

        //1.使用druid连接SQL
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));
        //获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
        //获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        //2.定义SQL语句，注意修改表名为 tb_brand
        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);//这样写可以输出boolean类型 true或者false

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

 1.3.3修改操作

• SQL语句:
      
  

UPDATE tb_brand
SET
    brand_name = ?,
    company_name = ?,
    ordered = ?,
    description = ?,
    status = ?
WHERE id = ?;

• 参数:需要所有的数据参数
  
  结果:返回Boolean值
      

package example;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import pojo.Brand;

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

/*
对品牌的增删改查操作
操作流程 连接数据库->写SQL语句->把语句赋给PreparedStatement对象->执行SQL语句->返回执行语句->释放资源
 */
public class BrandTest1 {
    /*
    修改操作
    1.SQL语句:
    UPDATE tb_brand
SET
    brand_name = ?,
    company_name = ?,
    ordered = ?,
    description = ?,
    status = ?
WHERE id = ?;

    2.参数:需要所有的数据参数
    3.结果:返回Boolean值
     */

    @Test
    public void testSelectAll() throws Exception {
        //接受页面提交的参数

        String brandName = "优乐美";
        String companyName = "优乐美";
        int ordered = 1000;
        String description = "你是我的优乐美";
        int status = 1;
        int id = 4;

        //1.使用druid连接SQL
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));
        //获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
        //获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        //2.定义SQL语句，注意修改表名为 tb_brand
        String sql = "UPDATE tb_brand\n" +
                "SET\n" +
                "    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);//这样写可以输出boolean类型 true或者false

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

1.3.4删除操作

 删除操作

•     sql语句:DELETE FROM tb_brand WHERE id = ?;
•     参数:根据id删除该行的全部数据
•     结果:返回Boolean值

package example;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import pojo.Brand;

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

/*
对品牌的增删改查操作
操作流程 连接数据库->写SQL语句->把语句赋给PreparedStatement对象->执行SQL语句->返回执行语句->释放资源
 */
public class BrandTest3 {
    /*
    删除操作
    1.sql语句:DELETE FROM tb_brand WHERE id = ?;
    2.参数:根据id删除该行的全部数据
    3.结果:返回Boolean值
     */

    @Test
    public void testSelectAll() throws Exception {
        //接受页面提交的参数

        int id = 4;

        //1.使用druid连接SQL
        Properties prop = new Properties();
        prop.load(new FileInputStream("D:\\软件\\iead daimalianxi\\EXP\\src\\druid.properties"));
        //获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
        //获取数据库连接 Connection
        Connection conn = dataSource.getConnection();

        //2.定义SQL语句，注意修改表名为 tb_brand
        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);//这样写可以输出boolean类型 true或者false

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

 六.API函数总结

1. DriverManager 类

• 注册驱动
  • Class.forName("com.mysql.cj.jdbc.Driver");
    • 加载数据库驱动类，将其注册到 DriverManager。
• 获取连接
  • Connection getConnection(String url, String user, String password)
    • 通过指定的 url、user 和 password 获取数据库连接。

2. Connection 接口

• 创建 Statement 对象
  • Statement createStatement()
    • 创建一个 Statement 对象，用于执行 SQL 语句。
• 创建 PreparedStatement 对象
  • PreparedStatement prepareStatement(String sql)
    • 创建一个 PreparedStatement 对象，用于执行预编译的 SQL 语句，预防 SQL 注入。
• 创建 CallableStatement 对象
  • CallableStatement prepareCall(String sql)
    • 创建一个 CallableStatement 对象，用于调用存储过程。
• 管理事务
  • void commit()
    • 提交当前事务。
  • void rollback()
    • 回滚当前事务。
  • void setAutoCommit(boolean autoCommit)
    • 设置自动提交模式。

3. Statement 接口

• 执行更新操作
  • int executeUpdate(String sql)
    • 执行 SQL 语句（如 INSERT、UPDATE、DELETE），返回受影响的行数。
• 执行查询操作
  • ResultSet executeQuery(String sql)
    • 执行 SQL 查询语句，返回 ResultSet 对象。
• 获取生成的键
  • ResultSet getGeneratedKeys()
    • 获取执行 INSERT 语句后生成的主键。

4. PreparedStatement 接口

• 设置参数
  • void setInt(int parameterIndex, int x)
    • 设置参数的值（示例：pstmt.setInt(1, 100)）。
  • void setString(int parameterIndex, String x)
    • 设置字符串类型的参数（示例：pstmt.setString(2, "John")）。
  • void setFloat(int parameterIndex, float x)
    • 设置浮点数类型的参数（示例：pstmt.setFloat(3, 10.5f)）。
• 执行 SQL
  • ResultSet executeQuery()
    • 执行查询语句，返回结果集。
  • int executeUpdate()
    • 执行更新语句，返回受影响的行数。

5. ResultSet 接口

• 获取数据
  • boolean next()
    • 将光标移动到下一行，并返回是否有更多行。
  • int getInt(String columnLabel)
    • 获取整型列的值（示例：rs.getInt("id")）。
  • String getString(String columnLabel)
    • 获取字符串列的值（示例：rs.getString("name")）。
  • float getFloat(String columnLabel)
    • 获取浮点型列的值（示例：rs.getFloat("price")）。
• 关闭 ResultSet
  • void close()
    • 关闭 ResultSet 对象。

6. 数据库连接池（以 Druid 为例）

• 获取连接池对象
  • DataSource dataSource = DruidDataSourceFactory.createDataSource(Properties prop);
    • 通过配置文件创建 DataSource 对象。
• 获取数据库连接
  • Connection connection = dataSource.getConnection();
    • 从连接池获取数据库连接。