JDBC 和数据库连接池

最新推荐文章于 2024-11-11 08:41:40 发布
最新推荐文章于 2024-11-11 08:41:40 发布
阅读量360 收藏 2
点赞数 1
分类专栏： 后端开发基础知识点 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53125903/article/details/133925870
版权

文章目录

1. JDBC概述

1.1 基本介绍

image-20231015150325371

image-20231015150333004

1.2 模拟JDBC

JdbcInterface

package com.xjz.jdbc.myjdbc;

import java.io.ObjectOutputStream;

/**
 * @author xjz_2002
 * @version 1.0
 * 我们规定的 jdbc 接口(方法)
 */
public interface JdbcInterface {

    //连接
    public Object getConnection();

    //crud
    public void crud();

    //关闭连接
    public void close();
}

MysqlJdbcImpl.java

package com.xjz.jdbc.myjdbc;

/**
 * @author xjz_2002
 * @version 1.0
 * mysql 数据库实现类 jdbc 接口 [模拟] 【mysql厂商开发】
 */
public class MysqlJdbcImpl implements JdbcInterface{
    @Override
    public Object getConnection() {
        System.out.println("得到 mysql 的连接");
        return null;
    }

    @Override
    public void crud() {
        System.out.println("完成 mysql 增删改查");
    }

    @Override
    public void close() {
        System.out.println("关闭 mysql 的连接");
    }
}

OracleJdbcImpl.java

package com.xjz.jdbc.myjdbc;

/**
 * @author xjz_2002
 * @version 1.0
 * 模拟 oracle 数据库实现 jdbc
 */
public class OracleJdbcImpl implements JdbcInterface{
    @Override
    public Object getConnection() {
        System.out.println("得到 oracle 的连接 升级");
        return null;
    }

    @Override
    public void crud() {
        System.out.println("完成对 oracle 增删改查");
    }

    @Override
    public void close() {
        System.out.println("关闭 oracle 的连接");
    }
}

TestJdbcImpl.java

package com.xjz.jdbc.myjdbc;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class TestJdbcImpl {
    public static void main(String[] args) {
        //完成对 mysql 的操作
        JdbcInterface jdbcInterface = new MysqlJdbcImpl();
        jdbcInterface.getConnection();//通过接口来调用实现类[动态绑定]
        jdbcInterface.crud();
        jdbcInterface.close();

        //完成对 oracle 的操作
        System.out.println("================================");
        jdbcInterface = new OracleJdbcImpl();//通过接口来调用实现类[动态绑定]
        jdbcInterface.getConnection();
        jdbcInterface.crud();
        jdbcInterface.close();

    }
}

运行结果

image-20231015152124263

1.3 JDBC 带来的好处

image-20231015152152472

image-20231015152203499

1.4 JDBC API

image-20231015152219320

2. JDBC 快速入门

2.1 JDBC 程序编写步骤

  1. 注册驱动 - 加载Driver 类
  2. 获取连接 - 得到Connection
  3. 执行增删改查 - 发送SQL 给mysql执行
  4. 释放资源 - 关闭相关连接

2.2 JDBC 第一个程序

image-20231015152339497

USE xjz_db02;

CREATE TABLE actor( -- 演员表
	id INT PRIMARY KEY AUTO_INCREMENT,
	`name` VARCHAR(32) NOT NULL DEFAULT '',
	sex CHAR(1) NOT NULL DEFAULT '女',
	borndate DATETIME,
	phone VARCHAR(11));
	
SELECT * FROM actor;

package com.xjz.jdbc;

import com.mysql.jdbc.Driver;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author xjz_2002
 * @version 1.0
 * 这是第一个 Jdbc 程序，完成简单的操作
 */
public class Jdbc01 {
    public static void main(String[] args) throws SQLException {

        //前置工作：在项目下创建一个文件夹 比如 libs
        //将 mysql_connection_java.jar 拷贝到该目录下，点击 add to ...
        //1. 注册驱动
        Driver driver = new com.mysql.jdbc.Driver();//创建 driver 对象

        //2. 得到连接
        //代码解读
        //(1) jdbc.mysql //规定好表示协议，通过 jdbc的方式连接 mysql
        //(2) localhost 主机，可以是 ip 地址
        //(3) 3306 表示 mysql 监听的端口
        //(4) xjz_db02 连接到 mysql.dbms 的哪个数据库
        //(5) mysql 的连接本质就是前面学过的 socket 连接
        String url = "jdbc:mysql://localhost:3308/xjz_db02";
        //将 用户名和密码放入到 Properties 对象
        Properties properties = new Properties();
        //说明：user 和 password 是规定好，后面的值根据实际情况写
        properties.setProperty("user","root");
        properties.setProperty("password","123456");
        Connection connect = driver.connect(url, properties);

        //3. 执行 sql
        //String sql = "insert into actor values(null,'xjz','男','2002-01-01','110')";
        //String sql = "update actor set name = '周星驰' where id = 1";
        String sql = "delete from actor where id = 1";


        //statement 用于执行静态 SQL 语句并返回其生成的结果的对象
        Statement statement = connect.createStatement();
        int rows = statement.executeUpdate(sql);//如果是 dml 语句，返回的就是影响行数

        System.out.println(rows > 0 ? "成功" : "失败");

        //4. 关闭连接
        statement.close();
        connect.close();
    }
}

3. 获取数据库连接 5 种方式

3.1 方式 1

image-20231015155833178

3.2 方式 2

image-20231015155844092

3.3 方式 3

image-20231015155854563

3.4 方式 4

image-20231015155949607

3.5 方式 5

image-20231015155958064

package com.xjz.jdbc;

import com.mysql.jdbc.Driver;
import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @author xjz_2002
 * @version 1.0
 * 分析 java 连接 mysql 的 5种方式
 */
public class JdbcConn {

    //方式 1
    @Test
    public void connect01() throws SQLException {
        Driver driver = new Driver();//创建 driver 对象
        String url = "jdbc:mysql://localhost:3308/xjz_db02";
        //将 用户名和密码放入到 Properties 对象
        Properties properties = new Properties();
        //说明：user 和 password 是规定好，后面的值根据实际情况写
        properties.setProperty("user", "root"); //用户名
        properties.setProperty("password", "123456"); //密码
        Connection connect = driver.connect(url, properties);
        System.out.println("方式 1=" + connect);
    }

    //方式 2
    @Test
    public void connect02() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {
        //使用反射加载 Driver 类，动态加载，更加的灵活，减少依赖性
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) aClass.newInstance();

        String url = "jdbc:mysql://localhost:3308/xjz_db02";
        //将 用户名和密码放入到 Properties 对象
        Properties properties = new Properties();
        //说明：user 和 password 是规定好，后面的值根据实际情况写
        properties.setProperty("user", "root"); //用户名
        properties.setProperty("password", "123456"); //密码

        Connection connect = driver.connect(url, properties);
        System.out.println("方式 2=" + connect);
    }

    //方式 3 使用 DriverManager 替代 driver 进行统一管理
    @Test
    public void connect03() throws ClassNotFoundException, IllegalAccessException, InstantiationException, SQLException {

        //使用反射加载 Driver
        Class<?> aClass = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) aClass.newInstance();

        //创建 url 和 user 和 password
        String url = "jdbc:mysql://localhost:3308/xjz_db02";
        String user = "root";
        String password = "123456";

        DriverManager.registerDriver(driver); //注册 Driver 驱动

        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println("方式 3=" + connection);
    }

    //方式 4 使用 Class.forName 自动完成注册驱动，简化代码
    //这种方式获取连接是使用的最多的，推荐使用
    @Test
    public void connect04() throws ClassNotFoundException, SQLException {
        //使用反射加载了 Driver 类
        //在加载 Driver 类时，完成注册
        /*
            源码: 1. 静态代码块，在类加载时，会执行一次. 2. DriverManager.registerDriver(new Driver());
            3. 因此注册 driver 的工作已经完成
            static {
                try {
                    DriverManager.registerDriver(new Driver());
                } catch (SQLException var1) {
                    throw new RuntimeException("Can't register driver!");
                }
            }
         */
        Class.forName("com.mysql.jdbc.Driver");

        //创建 url 和 user 和 password
        String url = "jdbc:mysql://localhost:3308/xjz_db02";
        String user = "root";
        String password = "123456";
        Connection connection = DriverManager.getConnection(url, user, password);

        System.out.println("第四种方式~" + connection);
    }

    //方式 5，在方式4的基础上改进，增加配置文件，让连接 mysql 更加灵活
    @Test
    public void connect05() throws IOException, ClassNotFoundException, SQLException {

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        Class.forName(driver);//建议写上，mysql 5.1.6之前必须写，之后可省略

        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println("方式 5=" + connection);
    }
}

3.6 课堂练习

image-20231015170951324

package com.xjz.jdbc;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class JdbcExercise {
    public static void main(String[] args) throws IOException, SQLException {

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        Connection connection = DriverManager.getConnection(url, user, password);
        //String sql = "insert into news values(null,'xjz','男','2002-01-01','110')";
        //String sql = "update news set phone = 666 where id = 1";
        String sql = "delete from news where id = 3";

        //statement 用于执行静态 SQL 语句并返回其生成的结果的对象
        Statement statement = connection.createStatement();
        int rows = statement.executeUpdate(sql);//如果是 dml 语句，返回的就是影响行数

        System.out.println(rows > 0 ? "成功" : "失败");

        //关闭连接
        connection.close();
    }
}

4. ResultSet [ 结果集]

  • 基本介绍

image-20231015171105377

image-20231015171116403

  • 应用实例

image-20231015172947591

package com.xjz.jdbc.resultset_;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 select 语句返回 ResultSet，并取出结果
 */
@SuppressWarnings({"all"})
public class ResultSet_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver); //建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到 Statement
        Statement statement = connection.createStatement();

        //4. 组织 SQL
        String sql = "select id,name,sex,borndate from actor";
        //执行给定的 SQL 语句，该语句返回单个 Result 对象
        /*
        +----+-----------+-----+---------------------+
        | id | name | sex | borndate |
        +----+-----------+-----+---------------------+-------+
        | 4 | 刘德华 | 男 | 1970-12-12 00:00:00 |
        | 5 | jack | 男 | 1990-11-11 00:00:00 |
        +----+-----------+-----+---------------------+-------+
        */
        /*
        阅读 debug 代码 resultSet 对象的结构
        */

        ResultSet resultSet = statement.executeQuery(sql);

        //5. 使用 while 取出数据
        while (resultSet.next()) { //让光标向后移动，如果没有更多航，则返回 false
            int id = resultSet.getInt(1);//获取改行的第 1 列
            //int id1 = resultSet.getInt("id");//通过列名来获取值，推荐
            String name = resultSet.getString(2);//获取该行的第 2 列
            String sex = resultSet.getString("sex");
            Date borndate = resultSet.getDate("borndate");

            System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate);
        }

        //6. 关闭连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

5. Statement

  • 基本介绍

image-20231015174525528

  • Statement对象执行SQL语句，存在SQL注入问题
-- 演示 sql 注入
-- 创建一张表
CREATE TABLE admin( -- 管理员表
	`name` VARCHAR(32) NOT NULL DEFAULT '',
	pwd VARCHAR(32) NOT NULL DEFAULT '') CHARACTER SET utf8;
	
-- 添加数据
INSERT INTO admin VALUES('tom','123');

-- 查找某个管理是否存在

SELECT *
	FROM admin
	WHERE NAME = 'tom' AND pwd = '123';
	
-- SQL 注入
-- 输入用户名为 1 or'
-- 输入万能密码为 or '1' = '1
SELECT *
	FROM admin
	WHERE `name` = '1 or'' and pwd = ' OR '1' = '1';
	
SELECT * FROM admin
  • 应用实例 Statement_.java

image-20231015180031702

package com.xjz.jdbc.statement_;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 statement 的 SQL注入问题
 */
@SuppressWarnings({"all"})
public class Statement_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {

        Scanner scanner = new Scanner(System.in);

        //让用户输入管理员名和密码
        System.out.print("请输入管理员的名字："); //next()：当接收到 空格 或者 '就表示结束
        String admin_name = scanner.nextLine(); //说明：如果希望看到 SQL 注入，这里需要使用nextLine()
        System.out.print("请输入管理员的密码：");
        String admin_pwd = scanner.nextLine();

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver); //建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到 Statement
        Statement statement = connection.createStatement();

        //4. 组织 SQL
        String sql = "select name, pwd from admin where name='"
                + admin_name + "'and pwd = '" + admin_pwd + "'";
        ResultSet resultSet = statement.executeQuery(sql);
        if (resultSet.next()) {//如果查询到一条记录，则说明该管理存在
            System.out.println("恭喜，登陆成功~");
        } else {
            System.out.println("对不起，登录失败");
        }

        //关闭连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}
  • 执行结果

image-20231015182724474

6. PreparedStatement

6.1 基本介绍

image-20231015182834004

6.2 预处理好处

image-20231015182907709

6.3 应用案例

package com.xjz.jdbc.preparedstatement_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 PreparedStatement 使用
 */
@SuppressWarnings({"all"})
public class PreparedStatement_ {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        
        // 看 PreparedStatement 类图

        //让用户输入管理员名和密码
        System.out.print("请输入管理员的名字："); //next()：当接收到 空格 或者 '就表示结束
        String admin_name = scanner.nextLine(); //说明：如果希望看到 SQL 注入，这里需要使用nextLine()
        System.out.print("请输入管理员的密码：");
        String admin_pwd = scanner.nextLine();

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver); //建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到 Statement
        //3.1 组织 SQL，sql 语句的 ? 就相当于占位符
        String sql = "select name, pwd from admin where name = ? and pwd = ?";
        
        //3.2 preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        
        //3.3 给 ? 赋值
        preparedStatement.setString(1,admin_name);
        preparedStatement.setString(2,admin_pwd);

        //4. 执行 select 语句使用 executeQuery()
        //    如果执行的是 dml(update, insert, delete) 则使用executeUpdate()
        //    这里执行 executeQuery，不要写 sql
        
        ResultSet resultSet = preparedStatement.executeQuery();
        if (resultSet.next()) {//如果查询到一条记录，则说明该管理存在
            System.out.println("恭喜，登陆成功~");
        } else {
            System.out.println("对不起，登录失败");
        }

        //关闭连接
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}
  • 执行结果

image-20231015184807044

  • 执行 dml 语句，使用executeUpdate()方法
package com.xjz.jdbc.preparedstatement_;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import java.util.Scanner;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 PreparedStatement 使用
 */
@SuppressWarnings({"all"})
public class PreparedStatementDML_ {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);

        // 看 PreparedStatement 类图

        //让用户输入管理员名和密码
        System.out.print("请输入要删除管理员的名字："); //next()：当接收到 空格 或者 '就表示结束
        String admin_name = scanner.nextLine(); //说明：如果希望看到 SQL 注入，这里需要使用nextLine()
//        System.out.print("请输入管理员的新密码：");
//        String admin_pwd = scanner.nextLine();

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver); //建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到 Statement
        //3.1 组织 SQL，sql 语句的 ? 就相当于占位符
        //添加记录
//        String sql = "insert into admin values(?,?)";
        //更新记录
//        String sql = "update admin set pwd = ? where name = ?";
        //删除记录
        String sql = "delete from admin where name = ?";

        //3.2 preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //3.3 给 ? 赋值
        preparedStatement.setString(1, admin_name);
//        preparedStatement.setString(2, admin_name);

        //4. 执行 dml 语句使用 executeUpdate()
        int rows = preparedStatement.executeUpdate();
        System.out.println(rows > 0 ? "执行成功" : "执行失败");

        //关闭连接
        preparedStatement.close();
        connection.close();
    }
}

6.4 课堂练习

image-20231016161159191

package com.xjz.jdbc.preparedstatement_;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import java.util.Scanner;

/**
 * @author xjz_2002
 * @version 1.0
 * 课堂练习 dml语句
 */
@SuppressWarnings({"all"})
public class PreparedStatementDML_exer01 {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);

        // 看 PreparedStatement 类图

        //让用户输入管理员名和密码
//        System.out.print("请输入修改后管理员的名字："); //next()：当接收到 空格 或者 '就表示结束
//        String admin_newname = scanner.nextLine(); //说明：如果希望看到 SQL 注入，这里需要使用nextLine()
//        System.out.print("请输入要删除管理员的名字：");
//        String admin_name = scanner.nextLine();
//        System.out.print("请输入管理员的新密码：");
//        String admin_pwd = scanner.nextLine();

        //通过 Properties 对象获取配置文件的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //1. 注册驱动
        Class.forName(driver); //建议写上

        //2. 得到连接
        Connection connection = DriverManager.getConnection(url, user, password);

        //3. 得到 Statement
        //3.1 组织 SQL，sql 语句的 ? 就相当于占位符
        //添加记录
//        String sql = "insert into admin values(?,?)";
        //更新记录
//        String sql = "update admin set name = ? where name = ?";
        //删除记录
//        String sql = "delete from admin where name = ?";

        //查询全部记录，并显示在控制台
        String sql = "select * from admin";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //4. 执行 select 语句使用 executeQuery()
        //    如果执行的是 dml(update, insert, delete) 则使用executeUpdate()
        //    这里执行 executeQuery，不要写 sql

        System.out.println("查询到的全部记录如下：");
        ResultSet resultSet = preparedStatement.executeQuery();
        while (resultSet.next()) {//如果查询到一条记录，则输出说明该管理存在
            String name = resultSet.getString(1);
            String pwd = resultSet.getString(2);
            System.out.println(name +"--"+pwd);
        }

/*        //3.2 preparedStatement 对象实现了 PreparedStatement 接口的实现类的对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //3.3 给 ? 赋值
        preparedStatement.setString(1, admin_name);
//        preparedStatement.setString(2, admin_name);

        //4. 执行 dml 语句使用 executeUpdate()
        int rows = preparedStatement.executeUpdate();
        System.out.println(rows > 0 ? "执行成功" : "执行失败");
 */
        //关闭连接
        preparedStatement.close();
        connection.close();
    }
}

7. JDBC 的相关 API 小结

image-20231016163718387

image-20231016163736443

8. 封装 JDBCUtils 【关闭连接，得到连接】

8.1 说明

在 jdbc 操作中，获取连接 和 释放连接 是经常使用到的，可以将其封装JDBC连接的工具类 JDBCUtils

package com.xjz.jdbc.utils;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 这是一个工具类，完成对 mysql 的连接和关闭资源
 */
public class JDBCUtils {
    //定义相关的属性(4个)，因为只需要一份，因此，我们做出 static
    public static String user;//用户名
    public static String password;//密码
    public static String url;//url
    public static String driver;//驱动名

    //在 static代码块去初始化
    static {
        try {
            Properties properties = new Properties();
            properties.load(new FileInputStream("src\\mysql.properties"));
            //读取相关的属性值
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            url = properties.getProperty("url");
            driver = properties.getProperty("driver");
        } catch (IOException e) {
            //在实际开发中，我们可以这样处理
            //1. 将编程异常转成 运行异常
            //2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便
            throw new RuntimeException(e);
        }
    }

    //连接数据库，返回 Connection
    public static Connection getConnection(){

        try {
            return DriverManager.getConnection(url,user,password);
        } catch (SQLException e) {
            //1. 将编程异常转成 运行异常
            //2. 调用者，可以选择捕获该异常，也可以选择默认处理该异常，比较方便
            throw new RuntimeException(e);
        }
    }

    //关闭相关资源
    /*
        1. ResultSet 结果集
        2. Statement 或者 PreparedStatement
        3. Connection
        4. 如果需要关闭资源，就传入对象，否则传入 null
    */
    public static void close(ResultSet set, Statement statement, Connection connection){

        //判断是否为空
        try {
            if (set != null){
                set.close();
            }
            if (statement != null){
                statement.close();
            }
            if (connection != null){
                connection.close();
            }
        } catch (SQLException e) {
            //将编译异常转成运行异常抛出
            throw new RuntimeException();
        }
    }

}

package com.xjz.jdbc.utils;

import org.junit.jupiter.api.Test;

import java.sql.*;

/**
 * @author xjz_2002
 * @version 1.0
 * 该类演示如何使用 JDBCUtils 工具类，完成 dml 和 select
 */
public class JDBCUtils_Use {

    @Test
    public void testSelect() {
        //1. 得到连接
        Connection connection = JDBCUtils.getConnection();
        //2. 组织一个sql
        String sql = "select * from actor where id = ?";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //3. 创建PreparedStatement 对象
        try {
            preparedStatement = connection.prepareStatement(sql);
            //给占位符赋值
            preparedStatement.setInt(1, 3);
            //执行，得到结果集
            resultSet = preparedStatement.executeQuery();
            //遍历该结果集
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String sex = resultSet.getString("sex");
                Date borndate = resultSet.getDate("borndate");
                int phone = resultSet.getInt("phone");
                System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(resultSet, preparedStatement, connection);

        }
    }

    @Test
    public void testDML() {
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个 sql
        String sql = "update actor set name = ? where id = ?";
        // 测试 delete 和 insert，自己玩
        PreparedStatement preparedStatement = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            // 给占位符赋值
            preparedStatement.setString(1, "周星驰");
            preparedStatement.setInt(2, 2);
            //执行
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }
}

9. 事务

9.1 基本介绍

image-20231018104215583

9.2 应用实例

模拟经典的转账业务

package com.xjz.jdbc.transaction_;

import com.xjz.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 jdbc 中如何使用事务
 */
public class Transaction_ {

    //没有使用事务
    @Test
    public void noTransaction() {

        //操作转账的业务
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个 sql
        String sql = "update account set balance = balance - 100 where id = 1";
        String sql2 = "update account set balance = balance + 100 where id = 2";
        PreparedStatement preparedStatement = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtils.getConnection();//在默认情况下， connection 是默认自动提交
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();//执行第 1 条 sql 语句

            int i = 1 / 0;//抛出异常
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();//执行第 2 条 sql语句

        } catch (SQLException e) {

            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }

    //事务来解决
    @Test
    public void useTransaction() {

        //操作转账的业务
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个 sql
        String sql = "update account set balance = balance - 100 where id = 1";
        String sql2 = "update account set balance = balance + 100 where id = 2";
        PreparedStatement preparedStatement = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtils.getConnection();//在默认情况下， connection 是默认自动提交
            // 将 connection 设置为不自动提交
            connection.setAutoCommit(false);//开启了事务
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();//执行第 1 条 sql 语句

            int i = 1 / 0;//抛出异常
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();//执行第 2 条 sql语句
            //这里提交事务
            connection.commit();

        } catch (SQLException e) {
            //这里我们可以进行回滚，即 撤销执行的 SQL
            //默认回滚到事务开始的状态
            System.out.println("执行发生了异常，撤销执行的 sql");
            try {
                connection.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }
}

image-20231018111349912

9.5 课后练习

image-20231018112035154

 @Test
    public void testDML() {
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个 sql
        String sql = "insert into account values(?,?,?)";
        PreparedStatement preparedStatement = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            // 给占位符赋值
            preparedStatement.setInt(1,4);
            preparedStatement.setString(2, "king");
            preparedStatement.setDouble(3, 200);
            //执行
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }

package com.xjz.jdbc.transaction_;

import com.xjz.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author xjz_2002
 * @version 1.0
 * 事务课堂练习： tom 给 king 转 10元钱，使用事务完成
 */
public class Transaction_exer {
    //事务来解决
    @Test
    public void useTransaction() {
        
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个 sql
        String sql = "update account set balance = balance - 10 where id = 3";
        String sql2 = "update account set balance = balance + 10 where id = 4";
        PreparedStatement preparedStatement = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtils.getConnection();//在默认情况下， connection 是默认自动提交
            // 将 connection 设置为不自动提交
            connection.setAutoCommit(false);//开启了事务
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.executeUpdate();//执行第 1 条 sql 语句

            //int i = 1 / 0;//抛出异常
            preparedStatement = connection.prepareStatement(sql2);
            preparedStatement.executeUpdate();//执行第 2 条 sql语句
            //这里提交事务
            connection.commit();

        } catch (SQLException e) {
            //这里我们可以进行回滚，即 撤销执行的 SQL
            //默认回滚到事务开始的状态
            System.out.println("执行发生了异常，撤销执行的 sql");
            try {
                connection.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(null, preparedStatement, connection);
        }
    }
    
}
  • 执行结果

image-20231018112017030

10 批处理

  • 基本介绍

image-20231018112246332

  • 应用实例

image-20231018112406085

image-20231018112414707

image-20231018112435403

package com.xjz.jdbc.batch_;

import com.xjz.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 java 的批处理
 */
public class Batch_ {

    //传统方法，添加 5000 条记录到 admin2

    @Test
    public void noBatch() throws SQLException {

        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into admin2 values(null,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        System.out.println("开始执行");
        long start = System.currentTimeMillis();//开始时间
        for (int i = 0; i < 5000; i++) { // 5000 执行
                preparedStatement.setString(1, "jack" + i);
                preparedStatement.setString(2, "666");
                preparedStatement.executeUpdate();
        }
        long end = System.currentTimeMillis();//结束时间
        System.out.println("传统的方式 耗时=" + (end-start)); // 传统的方式 耗时=8531
        //关闭连接
        JDBCUtils.close(null,preparedStatement,connection);
    }


    //使用 批量方式 添加数据
    @Test
    public void useBatch() throws SQLException {

        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into admin2 values(null,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        System.out.println("开始执行");
        long start = System.currentTimeMillis();//开始时间
        for (int i = 0; i < 5000; i++) { // 5000 执行
            preparedStatement.setString(1, "jack" + i);
            preparedStatement.setString(2, "666");
            //将 sql 语句加入到批处理中  -> 看源码
            /*
            //1. //第一就创建 ArrayList - elementData => Object[]
            //2. elementData => Object[] 就会存放我们预处理的 sql 语句
            //3. 当 elementData 满后,就按照 1.5 扩容
            //4. 当添加到指定的值后，就 executeBatch
            //5. 批量处理会减少我们发送 sql 语句的网络开销，而且减少编译次数，因此效率提高
            public void addBatch() throws SQLException {
                synchronized(this.checkClosed().getConnectionMutex()) {
                    if (this.batchedArgs == null) {
                        this.batchedArgs = new ArrayList();
                    }
                for(int i = 0; i < this.parameterValues.length; ++i) {
                    this.checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
                }
                    this.batchedArgs.add(new PreparedStatement.BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
                }
             }
             */
            preparedStatement.addBatch();
            //当有 1000条记录时，再批量执行
            if ((i+1) % 1000 == 0) {//满 1000条 sql
                preparedStatement.executeBatch();
                //清空一把
                preparedStatement.clearBatch();
            }
        }
        long end = System.currentTimeMillis();//结束时间
        System.out.println("批量处理方式 耗时=" + (end-start)); // 批量处理方式 耗时=106
        //关闭连接
        JDBCUtils.close(null,preparedStatement,connection);
    }

}

11. 数据库连接池

11.1 5k次连接数据库问题

image-20231018181629587

package com.xjz.jdbc.datasource;

import com.xjz.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class ConQuestion {

    //代码 连接 mysql 5000 次
    @Test
    public void testCon(){

        //看看连接-关闭 connection 会耗用多久
        long start = System.currentTimeMillis();
        System.out.println("开始连接...");
        for (int i = 0; i < 5000; i++) {
            //使用传统的 jdbc 方式，得到连接
            Connection connection = JDBCUtils.getConnection();
            //做一些工作，比如得到 PreparedStatement ， 发送sql
            //..
            //关闭
            JDBCUtils.close(null,null,connection);
        }
        long end = System.currentTimeMillis();
        System.out.println("传输 5000次 耗时=" + (end-start));//传输 5000次 耗时=16484
    }
}

11.2 传统获取 Connection 问题分析

image-20231018182044041

11.3 数据库连接池种类

image-20231018182136242

11.4 C3P0 应用实例

使用代码实现 c3p0 数据库连接池，配置文件放src目录下 C3P0_.java

package com.xjz.jdbc.datasource;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.jupiter.api.Test;

import java.beans.PropertyVetoException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @author xjz_2002
 * @version 1.0
 * 演示 c3p0 的使用
 */
public class C3P0_ {

    //方式1：相关参数，在程序中指定 user, url, password 等
    @Test
    public void testC3P0_01() throws IOException, PropertyVetoException, SQLException {

        //1. 创建一个数据源对象
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        //2. 通过配置文件 mysql.properties 获取相关连接的信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\mysql.properties"));
        //读取相关的属性值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");

        //给数据源 comboPooledDataSource 设置相关的参数
        //注意：连接管理是由 comboPooledDataSource 来管理
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setJdbcUrl(url);
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);

        //设置初始化连接数
        comboPooledDataSource.setInitialPoolSize(10);
        //最大连接数
        comboPooledDataSource.setMaxPoolSize(50);
        //测试连接池的效率，测试对 mysql 5000次操作
        long start = System.currentTimeMillis();
        for (int i = 0; i < 5000; i++) {
            Connection connection = comboPooledDataSource.getConnection();//这个方法就是 DataSource 接口实现的
//            System.out.println("连接OK");
            connection.close();
        }
        long end = System.currentTimeMillis();
        // c3p0 5000次连接 mysql 耗时=659
        System.out.println("c3p0 5000次连接 mysql 耗时=" + (end-start));
    }

    //第二种方式 使用配置文件模板来完成

    //1. 将 c3p0 提供的 c3p0.config.xml 拷贝到 src 目录下
    //2. 该文件指定了连接数据库和连接池的相关参数
    @Test
    public void testC3P0_02() throws SQLException {

        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("xjz_2002");

        //测试 5000次连接 mysql
        long start = System.currentTimeMillis();
        System.out.println("开始执行...");
        for (int i = 0; i < 5000; i++) {
            Connection connection = comboPooledDataSource.getConnection();
            //System.out.println("连接ok~");
            connection.close();
        }
        long end = System.currentTimeMillis();
        // c3p0 的第二种方式 耗时=465
        System.out.println("c3p0 的第二种方式 耗时=" + (end-start));
    }
}

11.5 Druid(德鲁伊) 应用实例

image-20231018193400855

使用代码实现Druid(德鲁伊) 数据库连接池 Druid_.java

package com.xjz.jdbc.datasource;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.jupiter.api.Test;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 测试 druid 的使用
 */
public class Druid_ {

    @Test
    public void testDruid() throws Exception {
        //1. 加入 Druid.jar 包
        //2. 加入 配置文件 druid.properties，将该文件拷贝项目的 src 目录
        //3. 创建 Properties 对象，读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\druid.properties"));

        //4. 创建一个指定参数的数据库连接池，Druid 连接池
        DataSource dataSource =
                DruidDataSourceFactory.createDataSource(properties);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 500000; i++) {
            Connection connection = dataSource.getConnection();
            //System.out.println("连接成功！");
            connection.close();
        }
        long end = System.currentTimeMillis();
        //druid 连接池 操作 5000次 耗时=543
        System.out.println("druid 连接池 操作 500000次 耗时=" + (end - start));//664
    }
}

11.6 将 JDBCUtils 工具类改成 Druid(德鲁伊)实现

通过德鲁伊数据库连接池获取连接对象

package com.xjz.jdbc.datasource;

import com.xjz.jdbc.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.*;

/**
 * @author xjz_2002
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class JDBCUtilsByDruid_USE {

    @Test
    public void testSelect() {

        System.out.println("使用 druid 方式完成");
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个sql
        String sql = "select * from actor where id >= ?";
        PreparedStatement preparedStatement = null;
        ResultSet set = null;
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtilsByDruid.getConnection();
            System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection
            preparedStatement = connection.prepareStatement(sql);
            //给占位符赋值
            preparedStatement.setInt(1, 3);
            //执行，得到结果集
            set = preparedStatement.executeQuery();
            
            //遍历该结果集
            while (set.next()) {
                int id = set.getInt("id");
                String name = set.getString("name");
                String sex = set.getString("sex");
                Date borndate = set.getDate("borndate");
                String phone = set.getString("phone");
                System.out.println(id + "\t" + name + "\t" + sex + "\t" + borndate + "\t" + phone);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtilsByDruid.close(set, preparedStatement, connection);
        }
    }

}

12. Apache–DBUtils

12.1 先分析一个问题

image-20231019112031979

image-20231019112042014

    
    //使用土方法来解决 ResultSet =封装=> Arraylist
    @Test
    public ArrayList<Actor> testSelectToArrayList() {

        System.out.println("使用 druid 方式完成");
        //1. 得到连接
        Connection connection = null;
        //2. 组织一个sql
        String sql = "select * from actor where id >= ?";
        PreparedStatement preparedStatement = null;
        ResultSet set = null;
        //创建 ArrayList 对象，存放 actor 对象
        ArrayList<Actor> list = new ArrayList<>();
        //3. 创建PreparedStatement 对象
        try {
            connection = JDBCUtilsByDruid.getConnection();
            System.out.println(connection.getClass());//运行类型 class com.alibaba.druid.pool.DruidPooledConnection
            preparedStatement = connection.prepareStatement(sql);
            //给占位符赋值
            preparedStatement.setInt(1, 1);
            //执行，得到结果集
            set = preparedStatement.executeQuery();

            //遍历该结果集
            while (set.next()) {
                int id = set.getInt("id");
                String name = set.getString("name");
                String sex = set.getString("sex");
                Date borndate = set.getDate("borndate");
                String phone = set.getString("phone");
                //把得到的 resultset 的记录，封装到 Actor对象，放入到 list 集合中
                list.add(new Actor(id, name, sex, borndate, phone));
            }

            //System.out.println("list 集合数据=" + list);
            for (Actor actor : list) {
                System.out.println("id=" + actor.getId() + "\t" + actor.getName());
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtilsByDruid.close(set, preparedStatement, connection);
        }
        // 因为 arrayList 和 connection 没有任何关联，所以该集合可以复用
        return list;
    }

12.2 基本介绍

image-20231019114056579

12.3 应用实例

image-20231019114118109

package com.xjz.jdbc.datasource;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @author xjz_2002
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class DBUtils_USE {

    //使用 apache-DBUtils 工具类 + druid 完成对标的 crud 操作
    @Test
    public void testQueryMany() throws SQLException { //返回结果是多行的情况

        //1. 得到 连接(Druid)
        Connection connection = JDBCUtilsByDruid.getConnection();
        //2. 使用 DBUtils 类和接口，先引入 DBUtils 相关的jar，加入到本 Project
        //3. 创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //4. 就可以执行相关的方法，返回 ArrayList 结果集
        //String sql = "select * from actor where id >= ?";
        // 注意： sql 语句也可以查询部分列
        String sql = "select id,name from actor where id >= ?";
        //代码解读
        //(1) query 方法就是执行 sql 语句，得到 resultset -- 封装到 ArrayList 集合中
        //(2) 返回集合
        //(3) connection 集合
        //(4) sql：执行的 sql 语句
        //(5) new BeanListHandler<>(Actor.class): 在将 resultset -> Actor 对象 -> 封装到 ArrayList
        // 底层使用反射机制 去获取 Actor 类的属性，然后进行封装
        //(6) 1 就是给 sql 语句中的? 赋值，可以有多个值，因为是可变参数 Object... params
        //(7) 底层得到的 resultset ,会在 query 关闭, 关闭 PreparedStatment

        List<Actor> query =
                queryRunner.query(connection, sql, new BeanListHandler<>(Actor.class), 2);
        System.out.println("输出集合的信息");
        for (Actor actor : query) {
            System.out.print(actor);
        }

        //释放资源
        JDBCUtilsByDruid.close(null, null, connection);
    }

    //演示 apache-dbutils + druid 完成 返回的结果是单行记录(单个对象)
    @Test
    public void testQuerySingle() throws SQLException { //返回结果是多行的情况

        //1. 得到 连接(Druid)
        Connection connection = JDBCUtilsByDruid.getConnection();
        //2. 使用 DBUtils 类和接口，先引入 DBUtils 相关的jar，加入到本 Project
        //3. 创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //4. 就可以执行相关的方法，返回 单个对象
        String sql = "select * from actor where id = ?";
        // 代码解读
        // 因为我们返回的单行记录 --》 单个对象，使用的 Hander 是 BeanHandler
        Actor actor =
                queryRunner.query(connection, sql, new BeanHandler<>(Actor.class), 3);
        System.out.println(actor);

        //释放资源
        JDBCUtilsByDruid.close(null, null, connection);
    }

    //演示 apache-dbutils + druid 完成 返回的结果是单行单列--返回的就是 object
    @Test
    public void testScalar() throws SQLException { //返回结果是多行的情况

        //1. 得到 连接(Druid)
        Connection connection = JDBCUtilsByDruid.getConnection();
        //2. 使用 DBUtils 类和接口，先引入 DBUtils 相关的jar，加入到本 Project
        //3. 创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //4. 就可以执行相关的方法，返回单行单列，返回的就是 object
        String sql = "select name from actor where id = ?";
        // 说明：因为返回的是一个对象，使用的 handler 就是 ScalarHandler
        Object obj = queryRunner.query(connection, sql, new ScalarHandler(), 3);
        System.out.println(obj);

        //释放资源
        JDBCUtilsByDruid.close(null, null, connection);
    }


    //演示 apache-dbutils + druid 完成 dml (update, insert ,delete)
    @Test
    public void testDML() throws SQLException { //返回结果是多行的情况

        //1. 得到 连接(Druid)
        Connection connection = JDBCUtilsByDruid.getConnection();
        //2. 使用 DBUtils 类和接口，先引入 DBUtils 相关的jar，加入到本 Project
        //3. 创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();

        //4. 这里组织 sql 完成 update,insert,delete
        //String sql = "update actor set name = ? where id = ?";
        //String sql = "insert into actor values(null,?,?,?,?)";
        String sql = "delete from actor where id = ?";

        //代码解读
        //(1) 执行 dml 操作是 queryRunner.update()
        //(2) 返回的值是受影响的行数 (affected：受影响)
        //int affectedRows = queryRunner.update(connection,sql,"xjz",3);
        //int affectedRows = queryRunner.update(connection,sql,"李云龙","男","1927-10-1","129");
        int affectedRows = queryRunner.update(connection,sql,3);
        System.out.println(affectedRows > 0 ? "执行成功" : "执行没有影响到表");

        //释放资源
        JDBCUtilsByDruid.close(null, null, connection);
    }

}
  • 运行结果

image-20231019120435136

12. 4 表和 JavaBean 的类型映射关系

int,double 等在 java 中都用包装类，因为 mysql 中的所有类型都可能是 NULL，而 java 中只有引用数据类型才有 NULL 值

image-20231019120656077

13. DAO 和 增删改查通用方法-BasicDao

13.1 先分析一个问题

image-20231019121704417

image-20231019121748819

13.2 基本说明

image-20231019121803153

13.3 BasicDAO 应用实例

image-20231019121827140

Actor.java

package com.xjz.dao_.domain;

import java.util.Date;

/**
 * @author xjz_2002
 * @version 1.0
 * Actor 对象和 actor 表的记录对应
 */
public class Actor { //Javabean, POJO, Domain对象
    private Integer id;
    private String name;
    private String sex;
    private Date borndate;
    private String phone;

    public Actor() { //一定要给一个无参构造器[反射需要]
    }

    public Actor(Integer id, String name, String sex, Date borndate, String phone) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.borndate = borndate;
        this.phone = phone;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBorndate() {
        return borndate;
    }

    public void setBorndate(Date borndate) {
        this.borndate = borndate;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "\nActor{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", borndate=" + borndate +
                ", phone='" + phone + '\'' +
                '}';
    }
}

JDBCUtilsByDruid.java

package com.xjz.dao_.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * @author xjz_2002
 * @version 1.0
 * 基于 druid 数据库连接池的工具类
 */
public class JDBCUtilsByDruid {

    private static DataSource ds;

    //在静态代码块完成 ds 初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src\\druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //编写 getConnection 方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //关闭连接，再次强调，在数据库连接池技术中，close 不是真的断掉连接
    //而是把使用的 Connection 对象放回到数据池中
    public static void close(ResultSet set, Statement statement, Connection connection){
        try {
            if (set != null){
                set.close();
            }
            if (statement != null){
                statement.close();
            }
            if (connection != null){
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

BasicDAO.java

package com.xjz.dao_.dao;

import com.xjz.dao_.utils.JDBCUtilsByDruid;
import com.xjz.jdbc.utils.JDBCUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @author xjz_2002
 * @version 1.0
 * 开发 BasicDAO，是其他 DAO 的父类，使用到 apache-dbutils
 */
public class BasicDAO<T> { //泛型指定具体类型

    private QueryRunner qr = new QueryRunner();

    //开发通用的 dml 方法，针对任意的表
    public int update(String sql, Object... parameters) {

        Connection connection = null;

        try {
            connection = JDBCUtilsByDruid.getConnection();
            int update = qr.update(connection, sql, parameters);
            return update;
        } catch (SQLException e) {
            throw new RuntimeException(e);//将编译异常->运行异常，抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }

    }

    //返回多个对象(即查询的结果是多行)，针对任意表

    /**
     * @param sql        sql语句，可以有 ?
     * @param clazz      传入一个类的 Class 对象，比如 Actor.class
     * @param parameters 传入 ? 的其他的值，可以是多个
     * @return 根据 Actor.class 返回对应的 ArrayList 集合
     */
    public List<T> queryMulti(String sql, Class<T> clazz, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new BeanListHandler<T>(clazz), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e);//将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }

    }

    //查询单行结果 的通用方法
    public T querySingle(String sql, Class<T> clazz, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new BeanHandler<T>(clazz), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e);//将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }


    //查询单行单列的方法,即返回单值的方法
    public Object queryScalar(String sql, Object... parameters) {

        Connection connection = null;
        try {
            connection = JDBCUtilsByDruid.getConnection();
            return qr.query(connection, sql, new ScalarHandler(), parameters);

        } catch (SQLException e) {
            throw new RuntimeException(e); //将编译异常->运行异常 ,抛出
        } finally {
            JDBCUtilsByDruid.close(null, null, connection);
        }
    }

}

ActorDao.java

package com.xjz.dao_.dao;

import com.xjz.dao_.domain.Actor;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class ActorDAO extends BasicDAO<Actor>{
    //1. 就有 BasicDAO 的方法
    //2. 根据业务需求，可以编写特有的方法.
}

TestDAO.java

package com.xjz.dao_.test;

import com.xjz.dao_.dao.ActorDAO;
import com.xjz.dao_.domain.Actor;
import org.junit.jupiter.api.Test;

import java.util.List;

/**
 * @author xjz_2002
 * @version 1.0
 */
public class TestDAO {

    //测试 ActorDAO 对 actor 表 crud 操作
    @Test
    public void testActorDAO() {

        ActorDAO actorDAO = new ActorDAO();
        //1. 查询
        List<Actor> actors = actorDAO.queryMulti("select * from actor where id >= ?", Actor.class, 1);
        System.out.println("====查询结果====");
        for (Actor actor : actors) {
            System.out.println(actor);
        }

        //2. 查询单行记录
        Actor actor = actorDAO.querySingle("select * from actor where id = ?", Actor.class, 2);
        System.out.println("====查询单行结果====");
        System.out.println(actor);

        //3. 查询单行单列
        Object o = actorDAO.queryScalar("select name from actor where id = ?", 2);
        System.out.println("====查询单行单列值====");
        System.out.println(o);

        //4. dml 操作 insert,update,delete
        int update = actorDAO.update("insert into actor values(null,?,?,?,?)", "孔二愣子", "男", "1928-12-3", "222");

        System.out.println(update > 0 ? "执行成功" : "执行没有影响表");
    }
}

运行结果

image-20231019140435558

xjz_2002
关注
专栏目录
JDBC数据库连接池的使用
wopoli的博客
07-29 1806
如果使用C3P0数据库连接池，配置文件为c3p0-config.xml，注意该文件必须放在src文件夹下，并且只能使用该名称。如果使用druid数据库连接池，配置文件为druid.properties，注意该文件可以使用任意名称和存放在任意位置，但是一般存放在src文件夹下，并且使用druid命名。...
JDBC和数据库连接池,带源码和工具文件（在源码的libs文件夹里）！！！！
05-21
Java Database Connectivity (JDBC) 是Java编程...了解和掌握JDBC及数据库连接池对于Java开发者至关重要，它们是构建可扩展、高性能的Java数据库应用的基础。正确使用JDBC和连接池可以显著提升应用程序的效率和稳定性。
超级详细的JDBC和数据库连接池讲解
m0_69266818的博客
04-13 1185
详细介绍了jdbc和druid连接池，保证看完就会
chapter25 JDBC 和 数据库连接池学习笔记
你好, 我在学java的博客
02-01 2375
JDBC
JDBC 数据库连接池
qwerty147532的博客
12-18 1715
概念：存放数据库连接的一个容器（集合）Connection当系统运行起来之后，这个连接池就被创建，在这个连接池当中，会申请一些对象，当有用户来访问数据库的时候，就从这个连接池当中获取连接对象，用户访问结束之后，连接池对象会归还给容器是properties形式的#初始化连接数#最大等待时间maxwait = 5000 #最大连接数#初始化连接数#最大等待时间maxwait = 5000 #最大连接数#初始化连接数#最大等待时间。
JDBC-数据库连接池
喃灬疯的博客
11-08 1966
在开始本节之前，我们讨论一个问题：为什么需要数据库连接池❓🔰传统JDBC连接数据库的弊端传统的JDBC数据库连接使用来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证IP地址，用户名和密码(0.05s ~1s时间)。每次需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库连接操作将占用很多的系统资源，容易造成服务器崩溃。每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭,将导致数据库内存泄漏，最终将导致重启数据库。传统获取连接的方式，不能控制创建的。
JDBC与数据库连接池
热门推荐
lonelymanontheway的博客
10-24 3万+
JDBC简介，driver类型，JDBC连接，使用技巧； 连接，短连接，长连接，连接池； 池化思想； 配置，基本配置，关键配置，性能配置； 连接池工具； druid； HikariCP； flexy-pool；
JDBC——数据库连接池
Michelhjx的博客
12-17 1524
前言 前面我们学习了JDBC中如何连接数据库以及实现增删查改，没看的小伙伴请点击链接 JDBC概述及数据库连接方式、JDBC增删改 查操作，今天我们继续学习JDBC中的数据库连接池。 一、为什么要使用数据库连接池 我们先回忆一下，在开发基于数据库的Web项目时，传统的步骤应该是： 1.在主程序中建立数据库的连接 2.进行sql语句操作 3.断开数据库...
javaweb 之 JDBC 详解 数据库连接池
m0_73859807的博客
10-27 2323
JDBC 就是使用Java语言操作关系型数据库的一套API全称：( Java DataBase Connectivity ) Java 数据库连接。
Java数据库连接JDBC和数据库连接池Druid
07-07 2831
目录数据库连接JDBC数据库连接池Druid JDBC是Java Data Base Connectivity的缩写即Java数据库连接，JDBC所要学习的东西，就是Java操作各种关系型数据库的一套API，其中Java定义好了接口，各个数据库厂商分别对这些接口进行了实现，如果我们要操作MySQL，那么就需要用MySQL家的实现类，也就是对应的jar，我们习惯性的说是MySQL驱动。该驱动可以通过该网址下载。导入驱动jar包之后就可以可以操作对应的数据库了，该驱动jar包，提供了各种API。我们创建一个Db
JDBC以及数据库连接池的使用
sjsja的博客
04-24 1346
文章目录JDBC步骤数据库连接池1.概念2.接口规范方法3.第三方数据库连接池技术C3p0Druid：由阿里提供Druid工具类 JDBC 概念 ​ JDBC是sun公司提供的一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可，不同的数据库厂商对这套接口有不同的实现 步骤 首先jdbc只是一个接口规范，所以第一导入对应厂商的jar包 加载并将驱动类注册进内存区 //注册驱动的代码是在jar包已经定义好了 static { try {
关于JDBC与数据库连接池，你了解多少？
12-14
文章目录1 JDBC1.1 使用JDBC的基本步骤1.2 JDBC工具类构建1.3 数据库的CRUD1.4 Dao模式1.5 Statement安全问题1.6 PrepareStatement2 数据库连接池2.1 自定义数据库连接池2.2 解决自定义数据库连接池出现的问题。...
07 Oracle数据库恢复基础解析：从检查点到归档，一步步构建数据安全防线
超哥的博客
11-09 1033
检查点是Oracle数据库中的一个特殊事件，它的作用是将内存中的数据块同步到磁盘上，以确保数据的持久性。简单来说，就是让数据库“记住”到目前为止所有的更改。Redo日志是Oracle用来记录所有数据更改的日志文件。每次对数据库进行修改时，都会先写入Redo日志，然后再写入数据文件。这样，即使系统崩溃，也能通过Redo日志恢复数据。当数据库运行在归档模式下时，一旦当前的Redo日志文件满，Oracle会将其复制到一个安全的存储位置，并标记为已归档。这样可以长期保留Redo日志，便于历史数据的恢复。
2024.11.6-Redis的事务与持久化
whisper_Java 的博客
11-06 843
MULTI、EXEC、DISCARD和WATCH 是 Redis 事务相关的命令。Redis的事务是将一系列待执行的指令存到一个Queue中，并使用exec执行事务。​--1. Redis事务是一个独立的隔离机制：事务中的所有命令都会序列化到queue、并按顺序地执行queue里的指令。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。​​multi: 用于开启事务，将待执行的命令放入到队列中exec命令:负责触发并执行事务中的所有命令：discard: 用于取消组队。
随堂测微信小程序ssm+论文源码调试讲解
最新发布
u014445459的博客
11-11 703
微信小程序，简称小程序，英文名Mini Program，是一种全新的连接用户与服务的方式，可以快速访问、快速传播，并具有良好的使用体验。小程序的主要开发语言是JavaScript，它与普通web的开发有很多相似之处。小程序和普通网页开发并不是相同的东西，是有差异的。网页开发的渲染线程和脚本线程是互斥的，而在小程序中，确实分开的，分别在不同的线程之中运行。
Redis - 事务
ketil27的博客
11-08 869
Redis 的事务和MySQL的事务概念上是类似的.都是把⼀系列操作绑定成⼀组.让这⼀组能够批量执 ⾏.弱化的原⼦性:redis没有"回滚机制".只能做到这些操作"批量执⾏".不能做到"⼀个失败就恢复到 初始状态".不保证⼀致性:不涉及"约束". 也没有回滚.MySQL的⼀致性体现的是运⾏事务前和运⾏后,结果都 是合理有效的,不会出现中间⾮法状态.不需要隔离性:也没有隔离级别,因为不会并发执⾏事务(redis单线程处理请求).
掌握JDBC与数据库连接池技术及其源码解析
资源摘要信息:"本文档包含了关于JDBC和数据库连接池的详细信息，特别是针对Java和MySQL数据库的应用。文档不仅提供了源代码，还提供了相关的工具文件，这些工具文件位于源码包中的libs文件夹内。JDBC（Java Database...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xjz_2002

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值