JDBC 和数据库连接池

最新推荐文章于 2024-06-16 09:46:44 发布
最新推荐文章于 2024-06-16 09:46:44 发布
阅读量341 收藏 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
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JDBC和数据库连接池
qq_42068838的博客
07-03 418
一JDBC 1、概念：JDBC是 Java 访问数据库的标准规范.是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范. 2、原理：JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！每个数据库厂商都需 要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。 3、JDBC的开发步骤：步骤1:搭...
chapter25 JDBC 和 数据库连接池学习笔记
你好, 我在学java的博客
02-01 1923
JDBC
JDBC与数据库连接池
热门推荐
lonelymanontheway的博客
10-24 3万+
JDBC简介，driver类型，JDBC连接，使用技巧； 连接，短连接，长连接，连接池； 池化思想； 配置，基本配置，关键配置，性能配置； 连接池工具； druid； HikariCP； flexy-pool；
JDBC-数据库连接池
喃灬疯的博客
11-08 1553
在开始本节之前，我们讨论一个问题：为什么需要数据库连接池❓🔰传统JDBC连接数据库的弊端传统的JDBC数据库连接使用来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证IP地址，用户名和密码(0.05s ~1s时间)。每次需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库连接操作将占用很多的系统资源，容易造成服务器崩溃。每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭,将导致数据库内存泄漏，最终将导致重启数据库。传统获取连接的方式，不能控制创建的。
JDBC和数据库连接池,带源码和工具文件（在源码的libs文件夹里）！！！！
05-21
JDBC和数据库连接池,带源码和工具文件（在源码的libs文件夹里）！！！！
关于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 解决自定义数据库连接池出现的问题。...
Spring 数据库连接池（JDBC）详解
08-30
本篇文章主要介绍了基于Spring的JDBC基本框架搭建；基于Spring的JDBC增删改查；读取配置文件中的数据等，具有很好的参考价值。下面跟着小编一起来看下吧
JDBC 数据库连接池
01-19
　为了解决这个问题，引入了数据库连接池技术(个人认为数据库连接池技术是为解决这个问题的)，它是批量创建一批数据库连接，放到一个数据库连接池，在需要数据库连接时，像这个池子拿，用完后则将数据库连接还回...
实现jdbc数据库连接池
05-20
此类非常简单，免去了网上众多资料里所说的麻烦的tomcat配置，更强...不仅oracle,mysql,sqlserver2000都行，因为它依据的是你自己连接数据库的驱动。当然首先你要保证你拥有一个能连接自己数据库的对应驱动类。如下面以
Spring Security实现用户认证四：使用JWT与Redis实现无状态认证
不做菜虚困的博客
06-12 739
在基本的通信流程中，我们一般采用Session去存储用户的认证状态。在Spring Security实现用户认证三中讲过，在拿到前端传输过来的用户名和密码之后，会有专门的过滤器处理这部分的需求，并且对认证成功的用户生成Token且存储在Session中。在下次发起请求时，直接从Session中取出同用户名的token进行密码哈希的比较要认证用户。对于无状态认证，则我们的认证不依赖与服务器端存储的Session的状态。所以无状态认证需要我们每次从前端传输一个包含完整认证信息的Token到服务器端进行自定义的认
基于springboot的青年公寓服务平台源码数据库
最新发布
s123456sj的博客
06-16 543
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
canal应用
qq_33816292的博客
06-12 135
canal分享模块链接。
源码编译安装LAMP
潇的博客
06-12 870
LAMP 架构是目前成熟的企业网站应用模式之一，指的是协同工作的一整套系统和相关软件，能够提供动态Web站点服务及其应用开发环境。LAMP是一个缩写词，具体包括Linux操作系统、Apache网站服务器、MySQL数据库服务器、PHP(或Perl、Python)网页编程语言。本章将以源码编译的方式搭建LAMP环境，能够满足企业定制化的需求。在构建LAMP平台时，各组件的安装顺序依次为Linux、Apache、MySQL、PHP。其中Apache和MySQL的安装并没有严格的顺序；
Windows10 MySQL（8.0.37）安装与配置
XLB
06-16 215
新建变量：%MYSQL_HOME%\bin 点击确定，也可以单独在path设置成一条：C:\MySQL\mysql-8.0.37-winx64\bin即可。C:\Mysql\mysql-8.0.37-winx64 （安装路径）工具栏搜索：高级系统设置，或者鼠标右键此电脑>属性>高级系统设置。保存，将my.txt文件后缀改为.ini。编辑my.txt文件，输入以下内容。系统变量找到：Path 点击编辑。解压文件，解压到你想要的位置。(没错就是要点三个确定)新建my.txt文件。点击确定，确定，确定。
Django UpdateView视图
人生苦短，何妨一试
06-11 430
UpdateView是Django中的一个通用视图，用于处理对象的更新操作。它允许用户更新一个已经存在的对象。UpdateView通常与一个模型表单一起使用，这样用户就可以看到当前对象的值，并可以修改它们。
SpringBoot+MyBatis批量插入数据的三种方式
pscool的博客
06-12 827
在开发过程中，我们经常会遇到往数据库表中插入大量数据的场景，比如excel批量导入数据。那么该如何快速地插入数据呢？我们可以考虑使用批量插入来实现，实测100000条数据添加，后附具体实现代码。用一个 for 循环，把数据一条一条地插入。/*** 第一种方案，用 for语句循环插入 10万 条数据*/i < count;i++) {user.setName("方案1测试" + i);user.setGender("男");user.setUsername("方案1测试");
liquibase做数据库版本管理
weixin_44554979的博客
06-10 204
通过这个配置就会自动启动liquibase。
springboot连接多个库
sunyingboaini的博客
06-11 197
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
jdbc连接池和数据库连接池
10-28
JDBC连接池和数据库连接池是同一个概念，都是为了提高数据库连接的效率和性能而设计的。连接池是一组已经建立好的数据库连接，应用程序可以从连接池中获取连接，使用完毕后再将连接放回连接池中，以便下次使用。这样...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xjz_2002

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

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

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

打赏作者

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

抵扣说明：

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

余额充值