JDBC和连接池（包含遇到常见错误解析）

最新推荐文章于 2024-06-11 21:55:58 发布

物逝人飞528

最新推荐文章于 2024-06-11 21:55:58 发布

阅读量1.8k

点赞数 41

文章标签： java

本文链接：https://blog.csdn.net/qq_67247090/article/details/139172475

版权

使用 Apache-DButils与Druid操作

JDBC概述

原理图

JDBC快速入门

代码

package JDBC;

import com.mysql.jdbc.Driver;
import com.mysql.jdbc.Statement;

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

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 演示简单操作
 */
public class jdbc01 {
    public static void main(String[] args) throws SQLException {

        //前置工作：在项目下创建文件夹 如 libs
        //将mysql.jar 拷贝到 libs ，再ADD进数据库

        //1、注册驱动
        Driver driver = new Driver();

        //2、得到连接
        //解读 1、jdbc:mysql://    规定的表示协议，通过jdbc方式连接mysql
        //2、localhost 表示主机，可以使用 ip 地址
        //3、3306 表示 该主机的mysql 监听端口
        //4、xcz03 表示想连接到哪个数据库
        //5、mysql 连接本质上就是之前学过的 socket 连接
        String url = "jdbc:mysql://localhost:3306/xcz03?useUnicode=true&characterEncoding=utf8";
        //将用户名和密码放入到 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,'马德华','男','2003-03-25','1100')";
        //statement 用于执行静态 SQL 语句并返回其生成的结果的对象
        Statement statement = (Statement) connect.createStatement();  //用于执行静态的sql语句，并返回其生成的结果的对象
        int rows = statement.executeUpdate(sql);  //如果是dml语句，返回的就是影响的行数，不成功返回0
        System.out.println(rows+"行语句执行成功！！！");
        //4、关闭连接资源
        statement.cancel();
        connect.close();
    }
}

可能遇到的错误

1、注册驱动导入Driver这里

（1）jar 文件要先复制到桌面，然后再复制粘贴到 libs 目录下，在jar文件下有以下三个文件才是成功，导入的是 com.mysql.jdbc 的Driver

2、中文乱码问题

（2） sqlyog 里找到 actor 表，右键点改变表，查看字符集是否为 utf8，不是就修改为utf8

若是则在 url 表名字后面加上 ?useUnicode=true&characterEncoding=utf8，如图：

3、connect 标红的注意是不是忘记下面这条代码

获取数据库连接的五种方式

方式一

方式二

package JDBC;

import com.mysql.jdbc.Driver;

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

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 演示 mysql 第二种连接方式
 */
public class JDBCcon02 {
    public static void main(String[] args) throws SQLException, ClassNotFoundException, InstantiationException, IllegalAccessException {

        //使用反射加载 Driver 类， 动态加载，更加灵活，减少依赖性
        Class cls = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) cls.newInstance();

        String url = "jdbc:mysql://localhost:3306/xcz03";
        //将用户名和密码放入到 Properties 对象
        Properties properties = new Properties();
        //前面 user 与 password 不能乱改
        properties.setProperty("user","root");  //用户
        properties.setProperty("password","123456"); //密码

        Connection connect = driver.connect(url,properties);

        System.out.println("方式二= " + connect);

    }
}

方式三

package JDBC;

import com.mysql.jdbc.Driver;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 演示第三种连接方式
 */
public class JDBCcon03 {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException {
        //使用反射加载 Driver 类， 动态加载，更加灵活，减少依赖性
        Class cls = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) cls.newInstance();

        //创建 url 、 user 、 password
        String url = "jdbc:mysql://localhost:3306/xcz03";
        String user = "root";
        String password = "123456";

        //注册 Driver 驱动
        DriverManager.registerDriver(driver);
        //调用 getConnection 尝试建立连接
        Connection connection = DriverManager.getConnection(url,user,password);
        System.out.println("第三种连接 =" + connection);
    }
}

方式四

package JDBC;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 第四种 连接方式(推荐使用的方式)
 */
public class JDBCcon04 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //在加载 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:3306/xcz03";
        String user = "root";
        String password = "123456";

        //调用 getConnection 尝试建立连接
        Connection connection = DriverManager.getConnection(url,user,password);
        //关闭connection
        connection.close();
    }
}

方式五

可能报错：1、文件路径问题

解决办法：（1）右键配置文件，复制绝对路径替换new FileInputStream（）里面的内容

package 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.util.Properties;

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 演示第五种方式连接mysql(更灵活)
 */
public class JDBCcon05 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {

        //通过配置文件对象获取配置文件信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\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);   //可以不写，但是建议写上

        Connection connection = DriverManager.getConnection(url, user, password);

        System.out.println("连接方式五 = " + connection);

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

    }
}

方式五创建news表练习代码

package JDBC;

import com.mysql.jdbc.Statement;

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

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC
 * 演示第五种方式连接mysql(更灵活)
 */
public class JDBCcon05 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {

        //通过配置文件对象获取配置文件信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\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);   //可以不写，但是建议写上

        Connection connection = DriverManager.getConnection(url, user, password);

        System.out.println("连接方式五 = " + connection);

        //执行sql 语句 创建 news 表
        String sql = "create table news(id int , content varchar(255))";
        //statement 用于执行静态 SQL 语句并返回其生成的结果的对象
        Statement statement = (Statement) connection.createStatement();  //用于执行静态的sql语句，并返回其生成的结果的对象
        int rows = statement.executeUpdate(sql);  //如果是dml语句，返回的就是影响的行数，不成功返回0
        System.out.println(rows+"行语句执行成功！！！");
        //关闭 连接

    }
}

可能出现问题：中文乱码

解决办法：修改配置文件如下

user=root
password=******
url=jdbc:mysql://localhost:3306/xcz03?useUnicode=true&characterEncoding=utf8
driver=com.mysql.jdbc.Driver

ResultSet 结果集

实操代码

package JDBC.ResultSet_;

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

/**
 * @auther xcz
 * @data 2024/5/24
 * @project JDBC.ResultSet_
 * 演示select 语句返回 ResultSet ,并取出结果
 */
public class resultSet {
    public static void main(String[] args) throws ClassNotFoundException, SQLException, IOException {
        //通过配置文件对象获取配置文件信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\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);   //可以不写，但是建议写上
        //得到连接
        Connection connection = DriverManager.getConnection(url, user, password);
        //得到 Statement
        Statement statement = connection.createStatement();
        //组织 Sql 语句
        String sql = "SELECT id,NAME,sex,borndate FROM actor";
        //执行该语句，返回单个对象，ResultSet对象
        ResultSet resultSet = statement.executeQuery(sql);

        //使用 while 循环遍历输出数据
        while (resultSet.next()){
            int id = resultSet.getInt(1);  //获取该行第一个列数据
            String name = resultSet.getString(2);  //获取该行第二个列数据
            String sex = resultSet.getString(3);  //获取该行第三个列数据
            Date date = resultSet.getDate(4);  //获取该行第四个列数据
            System.out.println("id= "+id+"\t"+"name= "+name+"\t"+"sex="+sex+"\t"+"date="+date );
        }
        //关闭连接
        statement.cancel();
        resultSet.close();
        connection.close();
    }
}

Statement

SQL注入问题

Statement存在的SQL注入问题

package 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;

/**
 * @auther xcz
 * @data 2024/5/25
 * @project JDBC.Statement
 * 演示 SQL 注入问题
 */
public class statement {
    public static void main(String[] args) throws SQLException, ClassNotFoundException, IOException {
        //通过配置文件对象获取配置文件信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");  
        String password = properties.getProperty("password"); 
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //让管理员输入用户名与密码
        Scanner scanner = new Scanner(System.in);  // 万能用户: 1' or
        System.out.println("请输入用户名：");      //next()方法接收到 空格或 ' 就表示结束
        String username = scanner.nextLine(); //nextLine()方法 是接收到回车才表示输入结束，用这个才能看到SQL注入效果
        System.out.println("请输入密码：");// 万能密码: or '1' = '1
        String passwd = scanner.nextLine();
        //注册驱动
        Class.forName(driver);   //可以不写，但是建议写上
        //得到连接
        Connection connection = DriverManager.getConnection(url, user, password);
        //得到 Statement
        Statement statement = connection.createStatement();
        //组织 Sql 语句
        String sql = "SELECT userName,pwd FROM admin where userName = '" + username + "' and pwd = '"+ passwd +"'";
        //接收返回
        ResultSet resultSet = statement.executeQuery(sql);
        //while 判断是否登录成功
        if (resultSet.next()){
            System.out.println("登陆成功！！！");
        }else{
            System.out.println("登录失败，用户名或密码错误！");
        }
        //关闭连接
        resultSet.close();
        statement.cancel();
        connection.close();

    }
}

PreparedStatement

package JDBC.Statement;


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

/**
 * @auther xcz
 * @data 2024/5/25
 * @project JDBC.Statement
 * 演示 SQL 注入问题
 */
public class statement {
    public static void main(String[] args) throws SQLException, ClassNotFoundException, IOException {
        //通过配置文件对象获取配置文件信息
        Properties properties = new Properties();
        properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\src\\mysql.properties"));
        //获取相关的值
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");

        //让管理员输入用户名与密码
        Scanner scanner = new Scanner(System.in);  // 万能用户: 1' or
        System.out.println("请输入用户名：");      //next()方法接收到 空格或 ' 就表示结束
        String username = scanner.nextLine(); //nextLine()方法 是接收到回车才表示输入结束，用这个才能看到SQL注入效果
        System.out.println("请输入密码：");// 万能密码: or '1' = '1
        String passwd = scanner.nextLine();
        //注册驱动
        Class.forName(driver);   //可以不写，但是建议写上
        //得到连接
        Connection connection = DriverManager.getConnection(url, user, password);
        //得到 PreparedStatement
        //组织 Sql 语句，SQL语句中 ？是表示占位符
        String sql = "SELECT userName,pwd FROM admin where userName = ? and pwd = ?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //给 ？ 赋值
        preparedStatement.setString(1,username);
        preparedStatement.setString(2,passwd);

        //执行 select 语句使用 executeQuery()方法
        //执行 dml(update,insert,delete) 使用executeUpdate()方法
        //执行查询不需要再填入 sql 语句
        ResultSet resultSet = preparedStatement.executeQuery();
        //while 判断是否登录成功
        if (resultSet.next()){
            System.out.println("登陆成功！！！");
        }else{
            System.out.println("登录失败，用户名或密码错误！");
        }
        //关闭连接
        resultSet.close();
        preparedStatement.cancel();
        connection.close();
    }
}

JDBC 的 API

JDBC Utils（代码）

package JDBC.utils;

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

/**
 * @auther xcz
 * @data 2024/5/25
 * @project JDBC.utils
 */
public class JDBCUtils {
    //定义相关属性 4 个，只需要一份所以用 static
    private static String user; //用户名
    private static String password; //密码
    private static String url;  //url
    private static String driver;  //驱动名

    //在静态代码块中去初始化
    static{
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\src\\mysql.properties"));
            //获取相关的值
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
        } catch (IOException e) {
            //在实际开发中，把编译异常转换为运行异常，抛出去
            //调用者可以 选着捕获该异常，也可以选着默认处理该异常，更方便
            throw new RuntimeException(e);
        }
    }
        //连接数据库 ，返回 Connection
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,password);
    }
    //关闭相关资源
    //可能关闭的： ResultSet 结果集、Statement或者PreparedStatement，Connection
    public static void close(ResultSet set, Statement statement, Connection connection){
        try{
            if (set != null){
                set.close();
            }
            if (statement != null){
                statement.cancel();
            }
            if (connection != null){
                connection.close();
            }
        }catch (SQLException e){
            throw new RuntimeException(e);
        }
    }
}

使用 JDBC Utils 查询语句

package JDBC.utils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

/**
 * @auther xcz
 * @data 2024/5/25
 * @project JDBC.utils
 * 演示使用 utils工具类
 */
public class use_utils {
    public static void main(String[] args) {

        //1、得到链接
        Connection connection = null;
        //2、组织 SQL 语句
        String sql = "select * from actor";
        //再 finally 里面要用，所以要扩大作用范围，写在这里
        PreparedStatement preparedStatement = null;
        //使用 ResultSet 接收返回数据
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            //执行得到结果
            resultSet = preparedStatement.executeQuery();
            //while 循环遍历结果
            while (resultSet.next()){
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String sex = resultSet.getString("sex");
                Date date = resultSet.getDate("borndate");
                String phone = resultSet.getString("phone");
                System.out.println(id + "\t" + name +"\t"+ sex +"\t"+ date +"\t"+ phone);

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

事务（import）

批处理

package JDBC.batch_;

import JDBC.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

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

/**
 * @auther xcz
 * @data 2024/5/25
 * @project JDBC.batch_
 * 演示使用批量 方式添加数据
 */
public class Batch_ {
    public static void main(String[] args) throws SQLException {
        Batch_ batch_ = new Batch_();
        batch_.batch();
    }
    @Test
    public void batch() throws SQLException {
        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into admin values (?,?)";
        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, "123");
            //将 sql 语句加入到 批处理包中 -> 源码
            /*

             */
            preparedStatement.addBatch();
            //当有 1000 条记录时，再执行批量执行
            if ((i + 1) % 1000 == 0) {
                //执行 Batch 中的语句
                preparedStatement.executeBatch();
                //清空 Batch
                preparedStatement.clearBatch();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("批量方式 耗时:" + (end - start));
        //关闭连接
        JDBCUtils.close(null, preparedStatement, connection);
    }
}

数据库连接池

连接池示意图

连接池种类

C3P0的使用

C3P0下载地址，0.9.5.5版本

https://nchc.dl.sourceforge.net/project/c3p0/c3p0-bin/c3p0-0.9.5.5/c3p0-0.9.5.5.bin.zip?viasf=1

可能报错如下

解决办法：要加入两个jar包，mchange-commons-java-0.2.19.jar与c3p0-0.9.5.5.jar

成功：

C3P0-config.xml文件自己写

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!-- 数据源的名称，代表连接池  -->
    <named-config name="mysql">
        <!-- 配置数据库用户名 驱动类-->
        <property name="user">root</property>
        <!-- 配置数据库密码 -->
        <property name="password">123456</property>
        <!-- 配置数据库链接地址 -->
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/xcz03?useUnicode=true&amp;characterEncoding=UTF-8</property>
        <!-- 配置数据库驱动 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <!-- 每次增长的连接数 -->
        <property name="acquireIncrement">20</property>
        <!-- 初始化连接数 -->
        <property name="initialPoolSize">10</property>
        <!-- 最小连接数 -->
        <property name="minPoolSize">5</property>
        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize">30</property>
        <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default:0 -->
        <property name="maxStatements">0</property>
        <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0 -->
        <property name="maxStatementsPerConnection">0</property>
        <!--c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能 通过多线程实现多个操作同时被执行。Default:3 -->
        <property name="numHelperThreads">3</property>
        <!--用户修改系统配置参数执行前最多等待300秒。Default: 300 -->
        <property name="propertyCycle">3</property>
        <!-- 获取连接超时设置 默认是一直等待单位毫秒 -->
        <property name="checkoutTimeout">1000</property>
        <!--每多少秒检查所有连接池中的空闲连接。Default: 0 -->
        <property name="idleConnectionTestPeriod">3</property>
        <!--最大空闲时间,多少秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
        <property name="maxIdleTime">10</property>
        <!--配置连接的生存时间，超过这个时间的连接将由连接池自动断开丢弃掉。当然正在使用的连接不会马上断开，而是等待它close再断开。配置为0的时候则不会对连接的生存时间进行限制。 -->
        <property name="maxIdleTimeExcessConnections">5</property>
        <!--两次连接中间隔时间，单位毫秒。Default: 1000 -->
        <property name="acquireRetryDelay">1000</property>
        <!--c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试使用。Default: null -->
        <property name="automaticTestTable">Test</property>
        <!-- 获取connnection时测试是否有效 -->
        <property name="testConnectionOnCheckin">true</property>
    </named-config>
</c3p0-config>

Druid德鲁伊应用实例

Druid1.1.10版本地址：

https://repo1.maven.org/maven2/com/alibaba/druid/1.1.10/druid-1.1.10.jar

package Druid_;

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

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

/**
 * @auther xcz
 * @data 2024/5/27
 * @project 测试 Druid 的使用
 */
public class druid_ {
    @Test
    public void testDruid() throws Exception {
        //加入 druid_jar 包
        //加入配置文件 Druid_properties，拷贝到src目录
        //创建 properties 对象，读取配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src/Druid_properties.properties"));

        //创建一个指定参数数据库连接池， 即 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 耗时：540
        System.out.println("druid 耗时：" + (end - start));

    }
}

JDBCUtilsByDruid

package JDBC;

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;

/**
 * @auther xcz
 * @data 2024/5/27
 * @project 基于数据库连接池的工具类
 */
public class JDBUtilsByDruid {
    private static DataSource ds;

    //在静态代码块完成 ds 的初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("src/Druid_properties.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //编写 getConnection 方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //编写 关闭连接，数据库连接池技术中的close是将连接放回连接池，不是真的关闭
    public static void Close(ResultSet resultSet, Statement statement, Connection connection) throws SQLException {
        if (resultSet != null){
            resultSet.close();
        }
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }
}

工具类应用案例

package JDBC.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;

/**
 * @auther xcz
 * @data 2024/5/27
 * @project 基于数据库连接池的工具类
 */
public class JDBUtilsByDruid {
    private static DataSource ds;

    //在静态代码块完成 ds 的初始化
    static {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream("D:\\idea_java_project\\javaSE\\chapter25\\src\\Druid_properties.properties"));
            ds = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //编写 getConnection 方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    //编写 关闭连接，数据库连接池技术中的close是将连接放回连接池，不是真的关闭
    public static void close(ResultSet resultSet, Statement statement, Connection connection) throws SQLException {
        if (resultSet != null){
            resultSet.close();
        }
        if (statement != null){
            statement.close();
        }
        if (connection != null){
            connection.close();
        }
    }
}

Apache--DBUtils

下载 dbutils-1.3

https://archive.apache.org/dist/commons/dbutils/binaries/commons-dbutils-1.3-bin.zip

目前存在问题以及解决思路示意图

我的理解：就是建立一个java类对标数据库的每一条数据，在得到返回的resultSet的时候将其以对象形式存入ArrayList数组，形成对象数组，每个对象对应一条记录

工具使用代码

package JDBC.utils;

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

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

/**
 * @auther xcz
 * @data 2024/5/27
 * @project 使用 Apache-工具类 + Druid 的方式
 */
public class use_Apache {

    @Test
    //返回结果是多行的情况
    public void  testQueryMany() throws SQLException {
        //得到连接 druid
        Connection connection = JDBCUtilsByDruid.getConnection();
        //使用 DBUtils 类和接口 ，先引入 DBUtils 相关的 jar ，加入到项目库
        //创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //就可以执行相关的方法，返回 ArrayList 结果集
        String sql = "select * from actor where id >= ?";
        // query 方法就是执行 sql 语句 得到 resultSet  封装到 ArrayList 集合中
        //返回集合
        //connection ：连接   sql ：执行sql 的语句
        //new BeanListHandler<>(Actor.class) 是将 resultSet 中的Actor对象取出来 ，封装到 ArrayList 中
        //  底层使用反射机制，去获取 Actor 类的属性，然后再进行封装
        // 1： 就是给 sql 中的语句赋的值，因为是可变参数 Object... params
        List<Actor> list = queryRunner.query(connection,sql,new BeanListHandler<>(Actor.class),1);
        System.out.println("输出集合中的内容：");
        for (Actor actor : list){
            System.out.println(actor);
        }
        //释放资源
        JDBCUtilsByDruid.close(null,null,connection);
    }
}

底层源码分析

/**
         * 分析 queryRunner.query 方法
         * public <T> T query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) throws SQLException {
         *         PreparedStatement stmt = null;  定义 PreparedStatement
         *         ResultSet rs = null;            接收返回的 ResultSet
         *         Object result = null;            返回 ArrayList
         *
         *         try {
         *             stmt = this.prepareStatement(conn, sql);  创建 PreparedStatement
         *             this.fillStatement(stmt, params);        对 sql 语句中的 ？ 赋值
         *             rs = this.wrap(stmt.executeQuery());       执行 sql 语句 返回resultSet
         *             result = rsh.handle(rs);              返回的 resultSet ---> arrayList【用反射处理】
         *         } catch (SQLException var33) {
         *             this.rethrow(var33, sql, params);
         *         } finally {
         *             try {
         *                 this.close(rs);   关闭 resultSet
         *             } finally {
         *                 this.close((Statement)stmt);  关闭 PreparedStatement
         *             }
         *         }
         *
         *         return result;
         *     }
         */

使用 Apache-DButils与Druid操作

    @Test
    //演示 apache-dbutils + druid 完成 dml 操作(delete，insert ，update)
    public void testDml() throws SQLException {
        //得到连接 druid
        Connection connection = JDBCUtilsByDruid.getConnection();
        //使用 DBUtils 类和接口 ，先引入 DBUtils 相关的 jar ，加入到项目库
        //创建 QueryRunner
        QueryRunner queryRunner = new QueryRunner();
        //就可以组织 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 = ?";
        //执行 dml 操作是 queryRunner.update
        //返回的值为 受影响的 行数
        int affectedRow = queryRunner.update(connection,sql,7);
        System.out.println(affectedRow > 0 ? "执行成功！！！" : "执行没有影响到表数据");
        //释放资源
        JDBCUtilsByDruid.close(null,null,connection);
    }
}

注意java与Sql中数据类型对应

DAO增删改查-BasicDao

为什么学 BasicDao

使用 DAO 进行增删改查

package dao_.dao;

import dao_.domain.Actor;
import org.junit.jupiter.api.Test;

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

/**
 * @auther xcz
 * @data 2024/5/27
 * @project dao_.dao
 */
public class Actor_Dao extends BasicDao<Actor>{

    //可以使用 BasicDao 的所有方法
    //可以根据自己实际业务要求，写新的方法
    //测试对 actor 表的 crud 操作
    @Test
    public void testActorDao() throws SQLException {
        Actor_Dao actor_dao = new Actor_Dao();
        //查询测试
        List<Actor> list = actor_dao.queryMultiply("select * from actor where id >= ?",Actor.class,1);
        System.out.println("查询多行结果");
        for (Actor actor : list){
            System.out.println(actor);
        }
        //查询单行结果
        Actor actor = actor_dao.querySingle("select * from actor where id = ?",Actor.class,1);
        System.out.println("查询到的单行结果是：" + actor);
        //查询 单行单列
        Object o = actor_dao.queryScalar("select name from actor where id = ?",1);
        System.out.println("查询到单行单列结果：" + o);
        //执行 dml 操作    insert ，update ， delete
        int insert = actor_dao.update("insert into actor values(null,?,?,?,?)",
                "张无忌", "男", "2003-03-03", "321654987");
        System.out.println(insert > 0 ? "执行成功！！！":"未影响到 actor 表");
        //删除操作
//        int delete = actor_dao.update("delete from actor where name = ?","老王");
//        System.out.println(delete > 0 ? "执行成功！！！" : "actor 表未受到影响");
        //修改操作
        int update = actor_dao.update("UPDATE actor SET NAME = '小白' WHERE id = ?",8);
        System.out.println(update > 0 ? "修改成功！！！" : "actor表未受到影响");
    }
}

物逝人飞528

关注

41
点赞
踩
37

收藏

觉得还不错? 一键收藏
0
评论
JDBC和连接池（包含遇到常见错误解析）

*** 演示简单操作*///前置工作：在项目下创建文件夹如 libs//将mysql.jar 拷贝到 libs ，再ADD进数据库//1、注册驱动//2、得到连接//解读 1、jdbc:mysql:// 规定的表示协议，通过jdbc方式连接mysql//2、localhost 表示主机，可以使用 ip 地址//3、3306 表示该主机的mysql 监听端口//4、xcz03 表示想连接到哪个数据库//5、mysql 连接本质上就是之前学过的 socket 连接。
复制链接

扫一扫