【数据库连接池、Spring JDBC】

最新推荐文章于 2022-11-20 22:40:22 发布
最新推荐文章于 2022-11-20 22:40:22 发布
阅读量123 收藏
点赞数
分类专栏： JDBC mysql 文章标签： mysql 数据库 spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46932548/article/details/106444131
版权

【数据库连接池、Spring JDBC】

数据库连接池【重点】

概念：其实就是一个容器（集合），存放数据库连接的容器。

  • 当系统初始化好后，容器被创建，容器中会申请一些连接对象。当用户来访问数据库时，从容其中获取连接对象，用户访问完之后，会将连接对象归还给容器。

好处：

  1. 节约资源；
  2. 用户访问高效。

实现：

  1. 标准接口：Java.sql.DataSource
    • 方法，获取连接：getConnection()，返回Connection对象
    • 方法，归还连接：Connection.close()
      • 注意：如果连接对象是从线程池中获取的，那么调用Connection.close()方法，则不会再关闭连接了，而是归还连接。
  2. 一般我们不去实现它，有数据库厂商来实现：
    • C3P0：数据库连接池技术【比较老】
    • Druid：数据库连接池实现技术，由阿里巴巴提供

C3P0数据库连接池技术

步骤：

  1. 导入（两个）jar包 c3p0-0.9.5.5.jar和mchange-commons-java-0.2.19.jar
    • 注意：不要忘记导入数据库驱动jar包
  2. 定义配置文件：
    • 名称：c3p0.properties 或者 c3p0-config.xml
    • 路径：直接将文件放在src目录下即可
  3. 创建核心对象，数据库连接池对象 ComboPooledDataSource
  4. 获取连接：调用getConnection()方法。

c3p0-config.xml：

<c3p0-config>
   <!-- 使用默认的配置读取连接池对象-->
   <default-config>
      <!--  连接参数 -->
      <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
      <property name="jdbcUrl">jdbc:mysql:///PRACTISE?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone = GMT</property>
      <property name="user">root</property>
      <property name="password">root</property>

      <!-- 连接池参数 -->
      <!-- 初始连接数 -->
      <property name="initialPoolSize">5</property>
      <!-- 最大连接数 -->
      <property name="maxPoolSize">10</property>
      <!-- 最大等待时间 -->
      <property name="checkoutTimeout">2000</property>
      <!-- 最大空闲回收时间 -->
      <property name="maxIdleTime">1000</property>
   </default-config>
   
   <!-- 使用自定义的配置读取连接池对象-->
   <named-config name="otherc3p0">
      <!--  连接参数 -->
      <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
      <property name="jdbcUrl">jdbc:mysql:///PRACTISE?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone = GMT</property>
      <property name="user">root</property>
      <property name="password">root</property>

      <!-- 连接池参数 -->
      <!-- 初始连接数 -->
      <property name="initialPoolSize">5</property>
      <!-- 最大连接数 -->
      <property name="maxPoolSize">8</property>
      <!-- 最大等待时间 -->
      <property name="checkoutTimeout">2000</property>
      <!-- 最大空闲回收时间 -->
      <property name="maxIdleTime">1000</property>
   </named-config>
</c3p0-config>

C3P0演示：

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;


/**
 * C3P0演示
 */
public class C3P0Demo01 {
    public static void main(String[] args) throws SQLException {
        //1.1获取DataSource，使用默认配置
        DataSource ds1 = new ComboPooledDataSource();
        //1.2使用指定名称的配置，获取DataSource
        DataSource ds2 = new ComboPooledDataSource("otherc3p0");
        //2.1 通过默认配置获得的连接池对象获取连接，验证配置文件中最大连接数为10，即获取10个连接对象,并分别打印其地址值
        //如要获取十一个，则可以让某一个连接对象用完之后归还到数据库连接池中
        for (int i = 1; i <= 11; i++) {
            Connection connection = ds1.getConnection();
            System.out.println(i+":"+connection);

            //第五个人用完后归还连接对象到连接池
            if (i == 5){
                connection.close();
            }
            //这时第六个人获取的连接池对象就是第五个人归还的
        }
        //2.2 通过指定名称配置获得的连接池对象获取连接，验证配置文件中最大连接数为8，即获取是个连接对象,并分别打印其地址值
        for (int i = 1; i <= 8; i++) {
            Connection connection = ds2.getConnection();
            System.out.println(i+":"+connection);

            //第五个人用完后归还连接对象到连接池
            if (i == 5){
                connection.close();
            }
            //这时第六个人获取的连接池对象就是第五个人归还的
        }

    }
}

注意：一般只是用到空参的默认配置获取连接池对象。

Druid数据库连接池技术

步骤：

  1. 导入jar包 druid-1.0.26.jar
    • 注意：不要忘记导入数据库驱动jar包
  2. 定义配置文件：
    • 名称：是properties形式的，可以叫任意名字
    • 路径：可以放在任意的目录下
  3. 加载配置文件，获取Properties对象
  4. 获取数据库连接池对象 ，通过工厂类来获取：DruidDataSourceFactory
  5. 通过工厂类的方法createDataSource，参数传入Properties对象
  6. 获取连接：调用getConnection()方法。

Druid使用演示：

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * Druid演示
 */
public class DruidDemo {
    public static void main(String[] args) throws Exception {
        //1.导入jar包，Add as Library
        //2.定义配置文件druid.properties,加载配置文件
        Properties pro = new Properties();
        ClassLoader classLoader = DruidDemo.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("druid.properties");
        pro.load(inputStream);
        //3.通过工厂类获取数据库连接池对象：
        DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);
        //4.通过连接池对象获取连接对象
        Connection connection = dataSource.getConnection();

    }
}
Druid工具类

  1. 定义一个类JDBCUtils

  2. 提供静态代码块加载配置文件，初始化连接池对象

  3. 提供方法

    1. 获取连接方法：通过数据库连接池获取连接
    2. 释放资源
    3. 获取数据库连接池的方法
package cn.kaikeba.datasource.utils;

import cn.kaikeba.util.JDBCUtil;
import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * JDBC中通过Druid获取连接池的工具类
 */
public class JDBCUtils {
    private static DataSource ds;
    /**
     * 通过静态代码块，加载配置文件，初始化线程池对象
     */
    static{
        try {
            //1.创建Properties对象
            Properties pro = new Properties();
            //2.加载配置文件
            pro.load(JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties"));
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    /**
     * 获取连接对象
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
    /**
     * 释放资源
     */
    public static void close(Statement statement, Connection connection, ResultSet resultSet){
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        
    }
    public static void close(Statement statement,Connection connection){
        close(statement,connection,null);
    }
    /**
     * 获取线程池对象
     */
    public static DataSource getDataSource(){
        return ds;
    }
}
使用Druid工具类完成添加数据的操作
package cn.kaikeba.datasource.druid;

import cn.kaikeba.datasource.utils.JDBCUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * 在account表中添加一行数据
 */
public class DruidDemo {
    public static void main(String[] args)  {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            //1.通过Druid工具类获取连接对象
            connection = JDBCUtils.getConnection();
            //2.定义sql语句
            String sql = "INSERT INTO account VALUES(null,?,?)";
            //3.1 获取PreparedStatement对象,传入sql语句
            preparedStatement = connection.prepareStatement(sql);
            //3.2 给?赋值
            preparedStatement.setString(1,"田七");
            preparedStatement.setDouble(2,1500);
            //4.执行sql语句
            int count = preparedStatement.executeUpdate();
            //5.打印结果
            if (count > 0){
                System.out.println("添加数据成功！"+count+"行数据收到影响！");
            }else{
                System.out.println("添加失败");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            //6.释放资源
            JDBCUtils.close(preparedStatement,connection);
        }
    }
}

Spring JDBCTemplate

Spring JDBCTemplate：Spring框架对JDBC的简单封装，提供了一个JDBCTemplate对象简化JDBC的开发。

步骤：

  1. 导入jar包

  2. 创建JDBCTemplate对象，依赖于数据源DataSource

    • JDBCTemplate template = new JDBCTemplate(ds);

  3. 使用JDBCTemplate的方法来完成CRUD的操作

方法作用
update()执行DML语句,增、删、改
queryForMap()查询结果并将结果集封装为Map集合
queryForList()查询结果并将结果集封装为List集合
query()查询结果并将结果集封装为JavaBean对象
queryForObject()查询结果，将结果封装为对象

【注意】：

  1. queryForMap()方法查询的结果集长度只能是1；
  2. queryForList()方法将每一条记录封装为一个Map集合，再将Map集合装载到List集合中；
  3. query()的参数：RowMapper接口
    • 一般我们使用BeanPropertiesRowMapper实现类。可以完成数据到JavaBean的自动封装;
    • new new BeanPropertyRowMapper<类型>(类型.class)
    • 所想要转换成的类属性的数据类型应为相应包装类，否则在传递null值时会出现错误
  4. queryForObject()方法一般用于聚合函数语句的查询，需要传递基本数据类型的包装类的.class字节码对象

入门代码演示：

import cn.kaikeba.datasource.utils.JDBCUtils;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

/**
 * JDBCTemplate入门
 */
public class JDBCTemplateDemo {
    public static void main(String[] args) {
        //1. 导入jar包
        //2.获取DataSource对象
        DataSource ds = JDBCUtils.getDataSource();
        //3.创建JdbcTemplate对象
        JdbcTemplate template = new JdbcTemplate(ds);
        //4.定义sql语句
        String sql = "UPDATE account set name = ? where id = ?";
        //5.调用update方法，执行语句，参数传递sql语句及相应?的值
        int count = template.update(sql, "张利安", 1);
        //6.打印执行结果
        if (count > 0 ){
            System.out.println("数据修改成功！"+count+"行受到影响！");
        }else{
            System.out.println("数据修改失败！");
        }

    }
}

练习

需求：

使用practise数据库下的emp表，进行一下操作：

  1. 修改1001号数据的salary为10000；
  2. 添加一条数据；
  3. 删除刚才添加的数据；
  4. 查询id为1所有的记录，将其封装为Map集合，并遍历；
  5. 查询所有记录，将其封装为List，并遍历；
  6. 查询所有记录，将其封装为Emp对象的List集合，并遍历；
  7. 查询总的记录数。
package cn.kaikeba.jdbctemplate;

import cn.kaikeba.datasource.utils.JDBCUtils;

import cn.kaikeba.domain.Emp;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * JDBCTemplate练习
 */
public class JDBCTemplateDemo {
    //1. 导入jar包
    //2.获取DataSource对象
    static DataSource ds = JDBCUtils.getDataSource();

    //3.创建JDBCTemplate，传入ds对象
    static JdbcTemplate template = new JdbcTemplate(ds);

    /**
     * main方法测试
     * @param args
     */
    public static void main(String[] args) {
        //1. 修改1001号数据的salary为10000；
        text1();
        //2. 添加一条数据；
        text2();
        //3. 删除刚才添加的数据；
        text3();
        //4. 查询id为1所有的记录，将其封装为`Map`集合，并遍历；
        text4();

        //5. 查询所有记录，将其封装为`List`，并遍历；
        text5();
        //6. 查询所有记录，将其封装为`Emp`对象的`List`集合，并遍历；
        text6();
        //7. 查询总的记录数。
        text7();


    }

    /**
     * 修改1001号数据的salary为10000；
     */
    public static void text1() {
        //4.1 定义sql语句
        String sql1 = "UPDATE emp SET salary = ? WHERE id = ?";
        //5.1 执行sql语句
        int update1 = template.update(sql1, 10000, 1001);

    }

    /**
     * 添加一条数据；
     */
    public static void text2() {
        //4.2 定义sql语句；
        String sql2 = "INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES(NULL,?,?,?,?,?,?,?)";
        //5.2 执行sql语句
        int update2 = template.update(sql2, "张三丰", 2, 1009, "2001-06-21", 18000, null, 40);

    }

    /**
     * 删除刚才添加的数据；
     */
    public static void text3() {
        //4.3 定义sql语句；
        String sql3 = "DELETE FROM emp WHERE ename = ?";

        //5.3 执行sql语句
        int update3 = template.update(sql3, "张三丰");

    }

    /**
     * 查询id为1所有的记录，将其封装为`Map`集合；
     */
    public static void text4() {
        //4.4 定义sql语句；
        String sql4 = "SELECT * FROM emp WHERE id = ?";

        //5.4 执行sql语句
        Map<String, Object> map = template.queryForMap(sql4, 1001);
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Object value = map.get(key);
            System.out.println(key + "=" + value);
        }

    }

    /**
     * 查询所有记录，将其封装为`List`,并遍历；
     */
    public static void text5() {
        //4.5 定义sql语句；
        String sql5 = "SELECT * FROM emp";

        //5.5 执行sql语句
        List<Map<String, Object>> list1 = template.queryForList(sql5);
        for (Map<String, Object> map1 : list1) {
            System.out.println(map1);
        }

    }

    /**
     * 查询所有记录，将其封装为`Emp`对象的`List`集合；
     */
    public static void text6() {
        //4.6 定义sql语句；
        String sql6 = "SELECT * FROM emp";

        //5.6 执行sql语句
        //5.6.1 自定义RowMapper接口的实现类，使用匿名内部类
        List<Emp> list2 = template.query(sql6, new RowMapper<Emp>() {
            @Override
            public Emp mapRow(ResultSet resultSet, int i) throws SQLException {
                Emp emp = null;
                emp = new Emp(resultSet.getInt("id"), resultSet.getString("ename"), resultSet.getInt("job_id"), resultSet.getInt("mgr"), resultSet.getDate("joindate"), resultSet.getDouble("salary"), resultSet.getDouble("bonus"), resultSet.getInt("dept_id"));
                return emp;
            }
        });
        for (Emp emp : list2) {
            System.out.println(emp);
        }

        //5.6.2 使用BeanPropertyRowMapper类
        List<Emp> list3 = template.query(sql6, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : list3) {
            System.out.println(emp);
        }
    }

    /**
     * 查询总的记录数:
     */
    public static void text7(){
        //4.7 定义sql语句
        String sql7 = "SELECT COUNT(id) FROM emp";

        //5.7 执行sql语句
        Long total = template.queryForObject(sql7, Long.class);
        System.out.println(total);
    }

}
五岁能抬头1995
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
什么是数据池?-简单的例子
void的博客
03-26 8070
什么是数据池？前言：关于数据池的概念简单数据池的实现不使用数据池的情况：使用数据池的情况： 前言： 本文参考：https://segmentfault.com/a/1190000013308078 关于数据池的概念 连接池用于创建和管理数据库连接的缓冲池技术，缓冲池中的连接可以被任何需要他们的线程使用。当一个线程需要用JDBC对一个数据库操作时，将从池中请求一个连接。当这个连接使用完毕后，将返回...
Spring 数据库连接池（JDBC）详解
08-30
Spring 数据库连接池（JDBC）详解 本篇文章主要介绍了基于 Spring 的 JDBC 基本框架搭建、基于 Spring 的 JDBC增删改查、读取配置文件中的数据等，具有很好的参考价值。下面我们来详细讲解。 一、数据库连接池的...
Spring + jdbc +connection pool + transaction
qq_26182553的博客
07-13 270
1. 添加lib org.springframework spring-tx 3.2.6.RELEASE org.springframework spring-jdbc 3.2.6.RELEASE 2. 修改spring配置 <beans xmlns="http://www.springframework.org/
Java web----数据库连接池
bluzelee2011的专栏
01-12 988
池参数（所有池参数都有默认值）： 初始大小：10个 最小空闲连接数：3个 增量：一次创建的最小单位（5个） 最大空闲连接数：12个 最大连接数：20个 最大的等待时间：1000毫秒  四大连接参数 连接池也是使用四大连接参数来完成创建连接对象！  实现的接口 连接池必须实现：javax.sql.DataSource接口！  连接池返回的Connection对象，它的close
JDBC数据池的概念
09-13 134
在一个多层的企业级应用中，更大的可能是在客户端和一个EJB进行通信，采用EJB建立数据库连接。为了实现和改进可伸缩性和系统性能， 也可以采用连接缓冲池（connection pool）优化数据库连接。 Java Naming and Directory Interface (JNDI)JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件...
Druid数据库连接池+Spring JDBC+BeanUtils简单实现登录功能
12-10
JavaWeb Druid数据库连接池+Spring JDBC+BeanUtils简单实现登录功能，博客地址：https://blog.csdn.net/qq_44515800/article/details/121856426
Java-jdbc数据库连接池总结.doc
03-20
Java JDBC 数据库连接池技术是Java应用程序访问数据库的关键优化手段，尤其在Web应用程序中，它解决了传统JDBC连接方式存在的效率低下和资源浪费问题。Java JDBC（Java Database Connectivity）是Java语言与各种...
druid1.2.8 下载 数据库连接池
05-22
Druid是阿里巴巴开源的一个高性能、多功能的数据库连接池组件，它在Java开发中广泛应用于各种项目的数据库管理。在1.2.8版本中，Druid提供了一系列优化和改进，旨在提高数据库访问性能，增强监控能力，并简化数据库...
java数据库连接池.rar
12-05
总的来说，Java数据库连接池如C3P0和Druid，以及Spring的JdbcTemplate，都是为了优化数据库操作而设计的工具。它们各自有其特点和优势，开发者可以根据项目需求选择合适的技术。在使用过程中，充分理解和合理配置...
小数据池的概念
weixin_30596735的博客
06-17 402
小数据池 1.小数据池的定义 什么是小数据池? 小数据池就是Python中一种提高效率的方式,固定数据类型使用同一个内存地址 小数池 -- 支持: str,int,bool 小数据池是干嘛的? a = 1 b = 1 id 查看空间的内存地址 获取开辟空间的一种地址 print(id(a)) print(id(b)) 2.小数据池的范围 2.1数字 小数据池数字支持范围: -5 ~...
数据库连接池的概念
huojiao2006的博客
07-24 645
数据库连接池概述： 　　数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。 　　数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为...
再谈编码---小数据池(概念)
weixin_30488085的博客
09-18 95
　　 1. 小数据池小数据池在说小数据池之前. 我们先看一个概念. 什么是代码块:python程序是由代码块构成的. 一个代码块的文本作为python程序执行的单元.代码块: 一个模块, 一个函数, 一个类, 甚至每一个command命令都是一个代码块. 一个文件也是一个代码块, eval()和exec()执行的时候也是一个代码块 小数据池. 一种数据缓存机制. 也被称为驻留机制. 小数据池只...
数据源与数据池的概念（转载）
chc960609的博客
11-22 1067
数据源与数据池的概念 - 风中小郎君 - 博客园 (cnblogs.com) 数据源(DataSource)即数据来源,调用DataSource.getConnection(),即可获取一个连接,而无需关心连到哪个数据库,用户名/密码是什么.这比DriverManager.getConnection(url, user, password)要先进多了.我们就通过这个DataSource.getConnection()方法来弄清什么是数据源与连接池. DataSource有两种实现方式 直连数据库方式
数据库池的理解？
lsh8886的博客
11-20 227
数据库池的理解？
一篇文章搞懂 数据海洋 数据湖 数据池 数据水坑 数据孤岛 数据仓库 基本概念
happyfreeangel的博客
11-13 9700
一。数据湖 由数据驱动的决策非常流行。从数据科学，机器学习和高级分析到实时仪表板，决策者都需要数据来帮助做出决策。 该数据需要一个家，而数据湖是创建该家的首选解决方案。该术语由Pentaho的CTO James Dixon发明并首次描述，他在博客中写道：“如果您将数据集市视为瓶装水的存储库，经过清洗，包装和结构化以便于使用，那么数据湖就很大了。水体处于更自然的状态。数据湖的内容从源头流入整个湖中...
数据湖介绍
热门推荐
dazheng
06-20 2万+
数据湖介绍数据湖概念是2011年提出来的,数据湖是数据仓库的补充，是为了解决数据仓库漫长的开发周期，高昂的成本，细节数据丢失等问题出现的。 数据湖大多是相对于传统基于RDBMS系统的数据仓库，而从2011年前后，也就是数据湖概念出现的时候，很多数据仓库逐渐迁移到以Hadoop为基础的技术栈上，而且除了结构化数据，半结构化、非结构数据也逐渐的存储到数据仓库中，并提供此类服务
关于数据库连接池概念、原理、运行机制
xiaoweids的博客
05-19 392
概述 数据库连接池是负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个。那么其中的运行机制又是怎样的呢？今天主要介绍一下数据库连接池原理和常用的连接池。 01 为什么要使用连接池 数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。 一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，使用完都关闭连接，这样造成系统的性能低下。 数据库连接池的解决方案是在应用程序启动时建立足够的数据库连接，并讲这些连
资源池设计模式 (Resource Pool)和数据池的简单实现
weixin_30325793的博客
11-21 529
本人摘自：http://sourcemaking.com/design_patterns/object_pool Object PoolDesign Pattern Intent Object pooling can offer a significant performance boost; it is most effective in situations where th...
jdbc连接池和数据库连接池
最新发布
10-28
JDBC连接池和数据库连接池是同一个概念，都是为了提高数据库连接的效率和性能而设计的。...HikariCP是一个轻量级、高性能的数据库连接池，被广泛应用于Spring Boot等框架中。它的特点是快速、高效、易用、可靠、稳定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值