批处理和数据库连接池-天翼云

1. 批处理 838

1.1 基本介绍

1. 当需要成批插入或者更新记录时。可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率。

2. JDBC的批量处理语句包括下面方法:

addBatch():添加需要批量处理的SQL语句或参数

executeBatch():执行批量处理语句;

clearBatch():清空批处理包的语句

3. JDBC连接MySQL时，如果要使用批处理功能，请再url中加

参数?rewriteBatchedStatements= true

4.批处理往往和PreparedStatement一起搭配使用，可以既减少编译次数，又减少运行次数，效率大大提高

1.2 应用实例 838

1.演示向admin2表中添加5000条数据，看看使用批处理耗时多久

2.注意:需要修改配置文件jdbc.properties

url =jdbc:mysql://localhost:3306/数据库?rewriteBatchedStatements=true

批处理和数据库连接池

代码在com.stulzl.batch_.

Batch_

package com.stulzl.batch_;


import com.stulzl.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

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

//演示Java的批处理
public class Batch_ {

    //传统方法，添加5000条数据到admin2
    @Test
    public void noBatch() throws Exception {
        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++) {
            preparedStatement.setString(1,"jack"+i);
            preparedStatement.setString(2,"666");
            preparedStatement.executeUpdate();
        }
        long end = System.currentTimeMillis();//结束时间

        System.out.println("传统方式="+(end-start));//传统方式=4654
        //关闭连接
        JDBCUtils.close(null,preparedStatement,connection);
    }

    //使用批量添加方式
    @Test
    public void Batch() throws Exception {
        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++) {
            preparedStatement.setString(1,"jack"+i);
            preparedStatement.setString(2,"666");
            //将sql语句加入到批处理包中
            preparedStatement.addBatch();
            //当有1000记录时，再批量处理
            if((i+1)%1000==0){//满1000条sql语句
                preparedStatement.executeBatch();
                preparedStatement.clearBatch();//清空一把
            }
        }
        long end = System.currentTimeMillis();//结束时间

        System.out.println("批量方式="+(end-start));//批量方式=76
        //关闭连接
        JDBCUtils.close(null,preparedStatement,connection);
    }
}

代码在E:\java学习\初级\course171\db_

batch_

-- 批量处理  838
CREATE TABLE admin2
	(id INT PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(32) NOT NULL,
	PASSWORD VARCHAR(32) NOT NULL);
SELECT * FROM admin2 
DROP TABLE admin2

2. 数据库连接池 840

2.1 传统方法 5k 次连接数据库问题

1. 编写程序完成连接MySQL 5000次的操作

2. 看看有什么问题，耗时又是多久. =>数据库连接池

代码在com.stulzl.datasource_

ConQuestion

package com.stulzl.datasource_;

import com.stulzl.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.Connection;

//连接池问题引入   840
public class ConQuestion {
    //代码连接数据库5000次
    @Test
    //看看连接-关闭 connection 会耗用多
    public void testCon(){
        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 次 耗时=9620
    }
}

2.2 传统获取 Connection 问题分析 840

1. 传统的JDBC数据库连接使用DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证IP地址，用户名和密码(0.05s ~ 1s时间)。需要数据库连接的时候，就向数据库要求一个，频繁的进行数据库连接操作将占用很多的系统资源，容易造成服务器崩溃。

2.每一次数据库连接，使用完后都得断开，如果程序出现异常而未能关闭，将导致数据库内存泄漏，最终将导致重启数据库。

3. 传统获取连接的方式，不能控制创建的连接数量，如连接过多，也可能导致内存泄漏，MySQL崩溃。

4.解决传统开发中的数据库连接问题，可以采用数据库连接池技术(connection pool)。

2.3 数据库连接池基本介绍 841

1. 预先在缓冲池中放入定数量的连接，当需要建立数据库连接时，只需从“缓冲池"中取出一个，使用完毕之后再放回去。

2.数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用个现有的数据库连接，而不是重新建立一个。

3.当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中

批处理和数据库连接池

2.4 数据库连接池种类 841

1. JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由第三方提供实现[提供jar]

2.C3P0数据库连接池，速度相对较慢，稳定性不错(hibernate, spring)

3.DBCP数据库连接池，速度相对c3p0较快，但不稳定

4.Proxool数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点BoneCP数据库连接池，速度快

6.Druid(德鲁伊)是阿里提供的数据库连接池，集DBCP、C3P0、 Proxool优点于一身的数据库连接池

2.5 C3P0 应用实例 5000次连接数据库 842-843

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

代码在com.stulzl.c3p0_

C3P0_

package com.stulzl.c3p0_;

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

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

//演示c3p0的使用   842-843
public class C3P0_ {
//先放入jar包
    //方式 1： 相关参数，在程序中指定 user, url , password 等
    @Test
    public void testC3P0_01() throws Exception {
        //1.创建一个数据源对象
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        //2. 通过配置文件获取相关的信息
        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++){
            //这个方法就是从 DataSource 接口实现的
            Connection connection = comboPooledDataSource.getConnection();
            //System.out.println("连接成功");
            //关闭
            connection.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("c3p0 5000次连接耗时="+(end-start));//c3p0 5000次连接耗时=336
    }

    //方式二使用配置文件模板来完成   843
    //1. 将 c3p0 提供的 c3p0.config.xml 拷贝到 src 目录下
    //2. 该文件指定了连接数据库和连接池的相关参数
    @Test
    public void testC3P0_02() throws SQLException {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("hsp_edu");
        //测试连接池的效率, 测试对 mysql 5000 次操作
        long start = System.currentTimeMillis();
        for(int i=0;i<500000;i++) {
            Connection connection = comboPooledDataSource.getConnection();
            //System.out.println("连接成功~");
            connection.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("c3p0 第二种500000次连接耗时="+(end-start));//c3p0 第二种500000次连接耗时=1630
    }
}

配置文件c3p0-config.xml

<c3p0-config>
    <!-- 数据源名称代表连接池 -->
  <named-config name="hsp_edu">
<!-- 驱动类 -->
  <property name="driverClass">com.mysql.jdbc.Driver</property>
  <!-- url-->
  	<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/hsp_db02</property>
  <!-- 用户名 -->
  		<property name="user">root</property>
  		<!-- 密码 -->
  	<property name="password">lzl</property>
  	<!-- 每次增长的连接数-->
    <property name="acquireIncrement">5</property>
    <!-- 初始的连接数 -->
    <property name="initialPoolSize">10</property>
    <!-- 最小连接数 -->
    <property name="minPoolSize">5</property>
   <!-- 最大连接数 -->
    <property name="maxPoolSize">50</property>

	<!-- 可连接的最多的命令对象数 -->
    <property name="maxStatements">5</property> 
    
    <!-- 每个连接对象可连接的最多的命令对象数 -->
    <property name="maxStatementsPerConnection">2</property>
  </named-config>
</c3p0-config>

3. Druid(德鲁伊) 844

3.1 应用实例 844

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

代码在com.stulzl.druid_

Druid_

package com.stulzl.druid_;

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;

//演示的Druid的使用  844
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();
        System.out.println("druid连接池500000操作耗时="+(end-start));//druid连接池500000操作耗时=410
    }

}

配置文件druid.properties

#key=value
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/hsp_db02?rewriteBatchedStatements=true
username=root
password=lzl
#initial connection Size
initialSize=10
#min idle connecton size
minIdle=5
#max active connection size
maxActive=50
#max wait time (5000 mil seconds)
maxWait=5000

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

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

可以简单的演示下使用

代码在com.stulzl.jdbcutils_druid;

JDBCUtils_Druid

package com.stulzl.jdbcutils_druid;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

//这是一个基于druid的数据库连接池的工具类  845
//将 JDBCUtils 工具类改成 Druid(德鲁伊)实现
public class JDBCUtils_Druid {
    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 resultSet, Statement statement, Connection connection){
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

测试类JDBCUtils_Druid_USE

package com.stulzl.jdbcutils_druid;

import com.stulzl.utils.JDBCUtils;
import org.junit.jupiter.api.Test;

import java.sql.*;

//测试基于druid的数据库连接池的工具类  845
public class JDBCUtils_Druid_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;
        try {
            connection = JDBCUtils_Druid.getConnection();
            //3.创建preparedStatement对象
            preparedStatement = connection.prepareStatement(sql);

            //4. 给占位符赋值
            preparedStatement.setInt(1,2);

            //执行,得到结果集
            set = preparedStatement.executeQuery();

            //遍历该结果集
            while(set.next()){
                int id = set.getInt("id");//这里提示("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 {
            //关闭资源
            JDBCUtils_Druid.close(set,preparedStatement,connection);
        }
    }
}

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

批处理和数据库连接池

批处理和数据库连接池

1. 批处理 838

1.1 基本介绍

1.2 应用实例 838

代码在com.stulzl.batch_.

Batch_

代码在E:\java学习\初级\course171\db_

batch_

2. 数据库连接池 840

2.1 传统方法 5k 次连接数据库问题

代码在com.stulzl.datasource_

ConQuestion

2.2 传统获取 Connection 问题分析 840

2.3 数据库连接池基本介绍 841

2.4 数据库连接池种类 841

2.5 C3P0 应用实例 5000次连接数据库 842-843

代码在com.stulzl.c3p0_

C3P0_

配置文件c3p0-config.xml

3. Druid(德鲁伊) 844

3.1 应用实例 844

代码在com.stulzl.druid_

Druid_

配置文件druid.properties

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

代码在com.stulzl.jdbcutils_druid;

JDBCUtils_Druid

测试类JDBCUtils_Druid_USE

相关文章

Oracle数据恢复—Oracle报错“system01.dbf需要更多的恢复来保持一致性，数据库无法打开”的数据恢复案例

解析Spring Boot中的数据库分片策略

深入解析淘客返利系统中的分布式数据库选型与优化

SQL数据库学习：从基础到进阶的系统化教程

悲观锁与乐观锁的比较及其在数据库中的应用

数据库三范式的实际应用及其对数据库设计的影响

时间代码的编写技巧与常见问题

SQL数据库索引的创建与维护策略

MySQL数据库中常见的性能瓶颈及优化策略

数据库三范式设计与规范化过程详解

作者介绍

最新文章

Oracle数据恢复—Oracle报错“system01.dbf需要更多的恢复来保持一致性，数据库无法打开”的数据恢复案例

悲观锁与乐观锁的比较及其在数据库中的应用

数据库三范式的实际应用及其对数据库设计的影响

SQL数据库索引的创建与维护策略

数据库三范式设计与规范化过程详解

MySQL数据库中常见的性能瓶颈及优化策略

热门文章

Nacos数据持久化到MySQL

MySQL的间隙锁

关于PyTorch继承nn.Module出现raise NotImplementedError的问题解决方案

​云原生微服务K8s容器编排第七章之ETCD的使用及备份

oracle 数据库 中 如何将不带汉字的日期格式转换成带“年月日时分秒”格式的日期

【Error】kettle连接MySQL

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

【mysql】数值函数

Lc3-无重复字符的最长子串

深入理解MySQL中的范围访问方法：单索引与多索引优化策略

mysql之uniquekey学习。

解码方法 II。‘A‘ -＞ 1，‘B‘ -＞ 2，...‘Z‘ -＞ 26。*是1-9，不包含0。

实验三 视图和索引实验【数据库原理】

云原生微服务K8s容器编排第七章之ETCD的使用及备份

oracle 数据库中如何将不带汉字的日期格式转换成带“年月日时分秒”格式的日期

实验三视图和索引实验【数据库原理】