源码详解系列(八)--全面讲解HikariCP的使用和源码

最新推荐文章于 2024-08-26 13:51:57 发布
置顶 最新推荐文章于 2024-08-26 13:51:57 发布
阅读量1.5k 收藏 9
点赞数 2
分类专栏： 第三方Java类库或工具 文章标签： java 连接池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44872791/article/details/104388170
版权

简介

HikariCP是什么？

HikariCP 本质上就是一个数据库连接池。

HikariCP 解决了哪些问题？

创建和关闭数据库连接的开销很大，HikariCP 通过“池”来复用连接，减小开销。

为什么要使用 HikariCP？

  1. HikariCP 是目前最快的连接池。就连风靡一时的 boneCP 也停止维护，主动让位给它。SpringBoot 也把它设置为默认连接池。
  1. HikariCP 非常轻量。本文用到的 4.0.3 版本的 jar 包仅仅只有 156 KB，它的源码真的非常精炼。

本文要讲什么？

本文将包含以下内容(因为篇幅较长，可根据需要选择阅读)：

  1. 如何使用 HikariCP（入门、JMX 等）
  2. 配置参数详解
  3. 源码分析

如何使用 HikariCP

需求

使用 HikariCP 获取连接对象，对用户数据进行简单的增删改查。

项目环境

JDK：1.8.0_231

maven：3.6.3

IDE：Spring Tool Suite 4.6.1.RELEASE

mysql-connector-java：8.0.15

mysql：5.7.28

Hikari：4.0.3

引入依赖

项目类型 Maven Project，打包方式 jar。

 		<!-- test -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- hikari -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>4.0.3</version>
        </dependency>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>
        <!-- log -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <type>jar</type>
        </dependency>

编写 hikari.properties

本文使用配置文件的方式来配置 HikariCP，当然，我们也可以在代码中显式配置，但不提倡。因为是入门例子，这里我只给出了必需的参数，其他的参数后面会详细介绍。

jdbcUrl=jdbc:mysql://localhost:3306/github_demo?characterEncoding=utf8&serverTimezone=GMT%2B8
username=root
password=root

初始化连接池

初始化连接池时，我们可以在代码中显式指定配置文件，也可以通过启动参数配置。

// 加载配置文件，也可以无参构造并使用启动参数 hikaricp.configurationFile 指定配置文件（不推荐，后面会说原因）
HikariConfig config = new HikariConfig("/hikari2.properties");
HikariDataSource dataSource = new HikariDataSource(config);

初始化连接池之后，我们可以通过HikariDataSource.getConnection()方法获取连接对象，然后进行增删改查操作，这部分内容这里就不展示了。

如何使用 JMX 管理连接池

需求

开启 JMX 功能，并使用 jconsole 管理连接池。

开启JMX

在入门例子的基础上增加配置。这要设置 registerMbeans 为 true，JMX 功能就会开启。

#-------------JMX--------------------------------
# 是否开启 JMX
# 默认 false
registerMbeans=true

# 是否允许通过 JMX 挂起和恢复连接池
# 默认为 false
allowPoolSuspension=true

# 连接池名称。
# 默认自动生成
poolName=zzsCP

启动连接池

为了查看具体效果，这里让主线程进入睡眠 20 分钟。

    public static void main(String[] args) throws InterruptedException {
        HikariConfig config = new HikariConfig("/hikaricp_base.properties");
        HikariDataSource dataSource = new HikariDataSource(config);
        Thread.sleep(20 * 60 * 1000);
        dataSource.close();
    }

使用jconsole查看

运行 main 方法，使用 JDK 的工具 jconsole 连接我们的项目，在 MBean 选项卡可以看到我们的连接池。接下里，我们可以进行这样的操作：

  1. 通过 PoolConfig 动态修改配置（只有部分参数允许修改）；
  2. 通过 Pool 获取连接池的连接数（活跃、空闲和所有）、获取等待连接的线程数、挂起和恢复连接池、丢弃未使用连接等。

hikaricp_jmx

想了解更多 JMX 功能可以参考我的博客文章： 如何使用JMX来管理程序？

配置参数详解

相比其他连接池，HikariCP 的配置参数非常简单，其中有几个功能需要注意：

  1. HikariCP 借出连接时强制检查连接的活性，不像其他连接池一样可以选择不检查；
  2. 默认会检查 idleTimeout、maxLifetime，可以选择禁用，但不推荐；
  3. 默认不检查 keepaliveTime、leakDetectionThreshold，可以选择开启，推荐开启 leakDetectionThreshold 即可。

必需的参数

注意，这里 jdbcUrl 和 dataSourceClassName 二选一。

#-------------必需的参数--------------------------------
# JDBC 驱动中 DataSource 的实现类全限定类名。不支持 XA DataSource
# 如果指定， HikariCP 将使用 DataSouce.getConnection 获取连接而不是使用 DriverManager.getConnection，官方建议指定（mysql 除外）
# dataSourceClassName=

# 如果指定， HikariCP 将使用 DriverManager.getConnection 获取连接而不是使用 DataSouce.getConnection
jdbcUrl=jdbc:mysql://localhost:3306/github_demo?characterEncoding=utf8&serverTimezone=GMT%2B8

# 用户名和密码
username=root
password=root

常用的参数

# 从池中借出的连接是否默认自动提交事务
# 默认 true
autoCommit=true

# 当我从池中借出连接时，愿意等待多长时间。如果超时，将抛出 SQLException
# 默认 30000 ms，最小值 250 ms。支持 JMX 动态修改
connectionTimeout=30000

# 一个连接在池里闲置多久时会被抛弃
# 当 minimumIdle < maximumPoolSize 才生效
# 默认值 600000 ms，最小值为 10000 ms，0表示禁用该功能。支持 JMX 动态修改
idleTimeout=600000

# 多久检查一次连接的活性
# 检查时会先把连接从池中拿出来（空闲的话），然后调用isValid()或执行connectionTestQuery来校验活性，如果通过校验，则放回池里。
# 默认 0 （不启用），最小值为 30000 ms，必须小于 maxLifetime。支持 JMX 动态修改
keepaliveTime=0

# 当一个连接存活了足够久，HikariCP 将会在它空闲时把它抛弃
# 默认 1800000  ms，最小值为 30000 ms，0 表示禁用该功能。支持 JMX 动态修改
maxLifetime=1800000

# 用来检查连接活性的 sql，要求是一个查询语句，常用select 'x'
# 如果驱动支持 JDBC4.0，建议不设置，这时默认会调用  Connection.isValid() 来检查，该方式会更高效一些
# 默认为空
# connectionTestQuery=

# 池中至少要有多少空闲连接。
# 当空闲连接 < minimumIdle，总连接 < maximumPoolSize 时，将新增连接
# 默认等于 maximumPoolSize。支持 JMX 动态修改
minimumIdle=5

# 池中最多容纳多少连接（包括空闲的和在用的）
# 默认为 10。支持 JMX 动态修改
maximumPoolSize=10

# 用于记录连接池各项指标的 MetricRegistry 实现类
# 默认为空，只能通过代码设置
# metricRegistry=

# 用于报告连接池健康状态的 HealthCheckRegistry 实现类
# 默认为空，只能通过代码设置
# healthCheckRegistry=

# 连接池名称。
# 默认自动生成
poolName=zzsCP

很少用的参数

# 如果启动连接池时不能成功初始化连接，是否快速失败 TODO
# >0 时，会尝试获取连接。如果获取时间超过指定时长，不会开启连接池，并抛出异常
# =0 时，会尝试获取并验证连接。如果获取成功但验证失败则不开启池，但是如果获取失败还是会开启池
# <0 时，不管是否获取或校验成功都会开启池。
# 默认为 1
initializationFailTimeout=1

# 是否在事务中隔离 HikariCP 自己的查询。
# autoCommit 为 false 时才生效
# 默认 false
isolateInternalQueries=false

# 是否允许通过 JMX 挂起和恢复连接池
# 默认为 false
allowPoolSuspension=false

# 当连接从池中取出时是否设置为只读
# 默认值 false
readOnly=false

# 是否开启 JMX
# 默认 false
registerMbeans=true

# 数据库 catalog
# 默认由驱动决定
# catalog=

# 在每个连接创建后、放入池前，需要执行的初始化语句
# 如果执行失败，该连接会被丢弃
# 默认为空
# connectionInitSql=

# JDBC 驱动使用的 Driver 实现类
# 一般根据 jdbcUrl 判断就行，报错说找不到驱动时才需要加
# 默认为空
# driverClassName=

# 连接的默认事务隔离级别
# 默认值为空，由驱动决定
# transactionIsolation=

# 校验连接活性允许的超时时间
# 默认 5000 ms，最小值为 250 ms，要求小于 connectionTimeout。支持 JMX 动态修改
validationTimeout=5000

# 连接对象可以被借出多久
# 默认 0（不开启），最小允许值为 2000 ms。支持 JMX 动态修改
leakDetectionThreshold=0

# 直接指定 DataSource 实例，而不是通过 dataSourceClassName 来反射构造
# 默认为空，只能通过代码设置
# dataSource=

# 数据库 schema
# 默认由驱动决定
# schema=

# 指定连接池获取线程的 ThreadFactory 实例
# 默认为空，只能通过代码设置
# threadFactory=

# 指定连接池开启定时任务的 ScheduledExecutorService 实例（建议设置setRemoveOnCancelPolicy(true)）
# 默认为空，只能通过代码设置
# scheduledExecutor=

# JNDI 配置的数据源名
# 默认为空
# dataSourceJndiName=

源码分析

HikariCP 的源码少且精，可读性非常高。如果你没见过像诗一样的代码，可以来看看 HikariCP。

提醒一下，在阅读 HiakriCP 源码之前，需要掌握CopyOnWriteArrayList、AtomicInteger、SynchronousQueue、Semaphore、AtomicIntegerFieldUpdater、LockSupport等 JDK 自带类的使用。

注意，考虑到篇幅和可读性，以下代码经过删减。

HikariCP为什么快？

数据库连接池已经发展了很久了，也算是比较成熟的技术，使用比较广泛的类库有 boneCP、DBCP、C3P0、Druid 等等。眼看着数据库连接池已经发展到了瓶颈，所谓的性能提升也仅仅是一些代码细节的优化，这个时候，HikariCP 出现并快速地火了起来，与其他连接池相比，它的快不是普通的快，而是跨越性的快。下面是 JMH 测试的结果（[测试项目地址](brettwooldridge/HikariCP-benchmark: JHM benchmarks for JDBC Connection Pools (github.com))）。

DataSource_performance_test

HikariCP 为什么快？我看网上有很多的解释，例如，大量使用 JDK 并发包的工具来避免粗颗粒度的锁、FastList 等自定义类的使用、动态代理类等等。我觉得，这些都不是主要原因。

HikariCP 之所以快，更多的还是由于抽象层面的优化。

传统模型–中规中矩的模型

连接池，顾名思义，就是一个存放连接对象的池塘。几乎所有的连接池都会从代码层面抽象出一个池塘。池里的连接数量不是一成不变的，例如，连接失效了需要移除、新连接创建、用户借出或归还连接，等等，总结起来，对连接池的操作不外乎四个：borrow、return、add、remove。

连接池一般是这样设计的：borrow、remove 动作会将连接从池塘里拿出来，add、return 动作则会往池塘里添加连接。我把这种模型称为“传统模型”。

hikaricp_pool01

“传统模型”是比较中规中矩的模型，从抽象层面讲，它非常符合我们的现实生活，例如，某人借走我的钱，钱就不在我的钱包里了。我们熟知的 DBCP、C3P0、Druid 等等都是基于“传统模型”开发的。

标记模型–更少的锁

但是 HikariCP 就不一样了，它没有走老路，而是优化了“传统模型”，让连接池真正意义地实现了提速。

在“传统模型”中，borrow、return、add、remove 四个动作都需要加同一把锁，即同一时刻只允许一个线程操作池，并发高时线程切换将非常频繁。因为多个线程操作同一个池塘，连接出入池需要加锁来保证线程安全。针对这一点，我们是不是能做些什么呢？

HikariCP 是这样做的，borrow 的连接不会从池塘里取出，而是打上“已借出”的标记，return 的时候，再把这个连接的“已借出”标记去掉。我把这种做法称为“标记模型”。“标记模型”可以实现 borrow 和 return 动作不加锁。具体怎么做到的呢？

hikaricp_pool02

首先，我要 borrow 时，我需要看看池塘里哪一个连接可以借出。这里就涉及到读连接池的操作，因为池塘里的连接数量不是一成不变的，为了一致性，我们就必须加锁。但是，HikariCP 没有加，为什么呢？因为 HikariCP 容忍了读的不一致。borrow 的时候，我们实际上读的不是真正的池塘，而是当前池塘的一份快照。我们看看 HikariCP 存放连接的地方，是一个CopyOnWriteArrayList对象，我们知道，CopyOnWriteArrayList是一个写安全、读不安全的集合。

public class ConcurrentBag<T extends IConcurrentBagEntry> implements AutoCloseable {
   // 存放连接的集合
   private final CopyOnWriteArrayList<T> sharedList;
}

接着，当我们找到了一个可借出的连接时，需要给它打上借出的标记。注意，这时有可能出现多个线程都想给它打标记的情况，该怎么办呢？难道要加锁了吗？别忘了我们可以用 CAS 机制来更新连接的标记，这个时候就不需要加锁了。看看 HikariCP 就是这么实现的。

   public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException {
      final int waiting = waiters.incrementAndGet();
      try {
         for (T bagEntry : sharedList) {
            if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
               return bagEntry;
            }
         }


         return null;
      }
      finally {
         waiters.decrementAndGet();
      }
   }

于是，在“标记模型”里，只有 add 和 remove 才需要加锁，borrow 和 return 不需要加锁。通过这种颠覆式的设计，连接池的性能得到极大的提高。

这就是我认为的 HikariCP 快的最主要原因。

HikariCP主要的类

那么，我们来看看 HikariCP 的源码吧。

HikariCP 的类不多，最主要的就这几个，如图。不难发现，这种类结构和 DBCP2 很像。

这几个类可以分成四个部分：

  1. 用户接口。用户一般会使用DataSource.getConnection()来获取连接对象。
  2. JMX 支持。
  3. 配置信息。使用HikariConfig加载配置文件，或手动配置HikariConfig的参数，它一般会作为入参来构造HikariDataSource对象；
  4. 连接池。获取连接的过程为HikariDataSource.getConnection()->HikariPool.getConnection()->ConcurrentBag.borrow(long, TimeUnit)。需要注意的是，ConcurrentBag才是真正的连接池，而HikariPool是用来管理连接池的。

ConcurrentBag–最核心的类

ConcurrentBag可以算是 HikariCP 最核心的一个类，它是 HikariCP 底层真正的连接池，上面说的“标记模型”只要就是靠它来实现的。如果大家不想看太多代码的话，只看它就足够了。

在设计上，ConcurrentBag是一个比较通用的资源池，它可以是数据库连接的池，也可以是其他对象的池，只要存放的资源对象实现了IConcurrentBagEntry接口即可。所以，如果我们的项目中需要自己构建池的话，可以直接拿这个现成的组件来用。

public class ConcurrentBag<T extends IConcurrentBagEntry> implements AutoCloseable {
	private final CopyOnWriteArrayList<T> sharedList;
}

下面简单介绍下ConcurrentBag的几个字段：

ConCurrentBagUml

属性描述
CopyOnWriteArrayList sharedList存放着状态为使用中、未使用和保留三种状态的资源对象
ThreadLocal threadList存放着当前线程归还的资源对象
SynchronousQueue handoffQueue这是一个无容量的阻塞队列，出队和入队都可以选择是否阻塞
AtomicInteger waiters当前等待获取元素的线程数

这几个字段在ConcurrentBag中如何使用呢，这里拿borrow方法来说明下：

   public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException
   {
      // 1. 首先从threadList获取资源
       
      final List<Object> list = threadList.get();
      for (int i = list.size() - 1; i >= 0; i--) {
         final Object entry = list.remove(i);
         final T bagEntry = weakThreadLocals ? ((WeakReference<T>) entry).get() : (T) entry;
         if (bagEntry != null && bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
            return bagEntry;
         }
      }

      // 等待获取连接的线程数+1
      final int waiting = waiters.incrementAndGet();
      try {
         // 2.如果还没获取到，会从sharedList中获取对象
         for (T bagEntry : sharedList) {
            if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
               // 这一步我不是很懂，好像可有可无
               if (waiting > 1) {
                  listener.addBagItem(waiting - 1);
               }
               return bagEntry;
            }
         }
         // 从sharedList中获取不到资源，通知监听器创建资源（不一定会创建）
         listener.addBagItem(waiting);
        
         // 3.如果还没获取到，会堵塞等待空闲连接
         timeout = timeUnit.toNanos(timeout);
         do {
            final long start = currentTime();
            // 这里会出现三种情况，
            // 1.超时，返回null
            // 2.获取到资源，但状态为正在使用，继续循环
            // 3.获取到资源，元素状态为未使用，修改为已使用并返回
            final T bagEntry = handoffQueue.poll(timeout, NANOSECONDS);
            if (bagEntry == null || bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
               return bagEntry;
            }
            timeout -= elapsedNanos(start);
         } while (timeout > 10_000);
         // 4.超时了还是没有获取到，返回null
         return null;
      }
      finally {
         // 等待获取连接的线程数-1
         waiters.decrementAndGet();
      }
   }

在上面的方法中，唯一会造成线程阻塞的就是handoffQueue.poll(timeout, NANOSECONDS)，除此之外，我们没有看到任何的 synchronized 和 lock。

HikariPool–管理连接池

除了ConcurrentBag，HikariPool也是一个比较重要的类，它用来管理连接池。

HikariPoolUML

HikariPool 的几个字段说明如下：

属性类型和属性名说明
DataSource dataSource用于获取原生连接对象的数据源。一般我们不指定的话，使用的是DriverDataSource
ThreadPoolExecutor addConnectionExecutor执行创建连接任务的线程池。只开启一个线程执行任务。
ThreadPoolExecutor closeConnectionExecutor执行关闭原生连接任务的线程池。只开启一个线程执行任务。
ScheduledExecutorService houseKeepingExecutorService用于执行检查 idleTimeout、leakDetectionThreshold、keepaliveTime、maxLifetime 等任务的线程池。

为了更清晰地理解上面几个字段的含义，我简单画了个图，不是很严谨，将就看下吧。在这个图中，客户端线程可以调用进行 borrow、requite 和 remove 操作，houseKeepingExecutorService 线程可以调用进行 remove 操作，只有 addConnectionExecutor 可以进行 add 操作。

HikariPoolSimpleProcess

一些有趣的地方

掌握了上面的两个类，HikariCP 的整个源码视图应该就比较完整了。下面再说一些有趣的地方。

为什么HikariDataSource有两个HikariPool

在下面的代码中，HikariDataSource里竟然有两个HikariPool。

public class HikariDataSource extends HikariConfig implements DataSource, Closeable
{
   private final HikariPool fastPathPool;
   private volatile HikariPool pool;
}

为什么要这样做呢？

首先，从性能方面考虑，使用 fastPathPool 来创建连接会比 pool 更好一些，因为 pool 被 volatile 修饰了，为了保证可见性不能使用缓存。那为什么还要用到 pool 呢？

我们打开HikariDataSource.getConnection()，可以看到，pool 的存在可以用来支持双重检查锁。这里我比较好奇的是，为什么不把 HikariPool的引用给 fastPathPool？？这个问题大家感兴趣可以研究一下。

   public Connection getConnection() throws SQLException
   {
      if (fastPathPool != null) {
         return fastPathPool.getConnection();
      }

      HikariPool result = pool;
      if (result == null) {
         synchronized (this) {
            result = pool;
            if (result == null) {
               validate();
               pool = result = new HikariPool(this);
               this.seal();
            }
         }
      }

      return result.getConnection();
   }

其实，这两个HikariPool对象有两种取值情况：

取值一：fastPathPool = pool = new HikariPool(this)。当通过有参构造new HikariDataSource(HikariConfig configuration)来创建HikariDataSource就会出现这样取值；

取值二：fastPathPool = null;pool = new HikariPool(this)。当通过无参构造new HikariDataSource()来创建HikariDataSource就会出现这样取值。

所以，我更推荐使用new HikariDataSource(HikariConfig configuration)的方式，因为这样做的话，我们将使用 fastPathPool 来获取连接。

如何加载配置

HikariCP 加载配置的代码非常简洁。我们直接从PropertyElf.setTargetFromProperties(Object, Properties)方法开始看，如下。

   // 这个方法就是将properties的参数设置到HikariConfig中
   public static void setTargetFromProperties(final Object target, final Properties properties)
   {
      if (target == null || properties == null) {
         return;
      }
    
      // 获取HikariConfig的所有方法
      List<Method> methods = Arrays.asList(target.getClass().getMethods());
      properties.forEach((key, value) -> {
         // 如果是dataSource.*的参数，直接加入到dataSourceProperties属性
         if (target instanceof HikariConfig && key.toString().startsWith("dataSource.")) {
            ((HikariConfig) target).addDataSourceProperty(key.toString().substring("dataSource.".length()), value);
         }
         else {
            // 找到参数对应的setter方法并赋值
            setProperty(target, key.toString(), value, methods);
         }
      });
   }

相比其他类库（尤其是 druid），HikariCP 加载配置的过程非常简洁，不需要按照参数名一个个地加载，这样后期会更好维护。当然，这种方式我们也可以运用到实际项目中。

另外，配置 HikariCP 的时候不允许写错参数或者添加一些无关的参数，否则会因为找不到对应的 setter 方法而报错。

以上基本讲完 HikariCP 的源码。后续发现其他有趣的地方再做补充，也欢迎大家指正不足的地方。

最后，感谢阅读。

参考资料

HikariCP github

2021-05-20 修改

相关源码请移步：https://github.com/ZhangZiSheng001/hikari-demo

本文为原创文章，转载请附上原文出处链接： https://www.cnblogs.com/ZhangZiSheng001/p/12329937.html

双面神像
关注
专栏目录
HikariCP：一个叫光的JDBC连接池
诗酒年华
06-08 6022
天不生我李淳罡，剑道万古如长夜。Hikari [hi·ka·'lē] 是日语“光”的意思。HikariCP的卖点是快、简洁、可靠，整体非常轻量，只有130Kb左右。HikariCP的出现可以说是颠覆了连接池领域，就连曾经风靡一时的BoneCP也主动停止维护，让贤于他。而且，在Spring Boot 2.0中，HikariCP凭借其优越的性能取代Tomcat成为默认的数据库连接池。
SpringBoot学习2——整合事务、HikariCP、druid、thymeleaf、Restful简单入门
zzhou——blog
02-27 602
文章目录0.学习目标1. 了解SpringBoot1.1.什么是SpringBoot1.2.为什么要学习SpringBoot1.3.SpringBoot的特点2.快速入门2.1.创建工程2.2.引入依赖2.3.编写HelloController2.4.启动测试2.5.详解2.5.1.启动器2.5.2.@EnableAutoConfiguration2.6.优化入门程序2.5.1.添加引导类2.5....
1. HikariCP连接池优化配置小结
热门推荐
elegent Developer's 的博客
05-13 1万+
1. 什么是HikariCP连接池 Fast, simple, reliable. HikariCP is a “zero-overhead” production ready JDBC connection pool. At roughly 130Kb, the library is very light。 2. 为什么HikariCP连接池值得使用和研究 1）使用广泛 在上亿个站点中使用，每天服务的请求多达10亿；最重要的是它现在是spring boot的默认连接池。 2）一个印度阿三引起的口水战 h
使用HikariCP时需要的jar
06-10
使用HikariCP使用所需要的一些jar包。加到项目的Build Path中就可以使用HikariCP了。
HikariCP源码分析之源码环境搭建
最新发布
liuwenqiang1314的博客
08-26 401
为了方便记录以及查看一些历史的提交信息，我先在github上fork了这个源码库。他的原始源码库位置为在fork到我的源码库之后，我就可以用git clone拉取下来，然后在我本地打开，做一些修改和笔记。然后提交到我自己的源码库上面了。这样比起你直接下载源码zip包的好处就是，你可以看到每一行代码的提交信息，得以知道他们提交的时候修改了什么以及提交的注释等等。
数据源从druid迁移到HikariCP
weixin_33717298的博客
06-19 682
最近正好在做新项目，使用的是druid数据源，也真是巧，有朋友建议我使用HikariCP这个数据源，可以说是牛的一笔，速度快的飞起，性能极高！ 要比druid不知道好多少倍，druid其实在某些情况下是有问题的 另外springboot2.0 也已经把默认的数据源改为了HikariCP 什么是HikariCP，Hikari 就是 日文【光】的意思，大家可以自行百度 下面附上改数据源的具体配置，另外...
Hikaricp简单使用
u012432389的博客
06-25 2357
2017/09/18 Hikaricp简单使用 Hikaricp 替换现有的数据库连接池也是很方便的 没有时间去测试 现贴出简单的配置 如果使用spring，只需要简单的替换 <bean id="hikariDataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="shutdown"&g...
hikaricp使用
qq_36712111的博客
02-18 3526
hikaricp数据库连接池是目前很流行的数据源 1.需要引入mysql的驱动、hikaricp依赖 &lt;properties&gt; &lt;java.version&gt;1.8&lt;/java.version&gt; &lt;hikari.version&gt;2.7.9&lt;/hikari.version&gt; &lt;mysql.version&gt;8.0.13...
在 Spring Boot 中使用 HikariCP 连接池
沉默王二
06-27 6648
上次帮小王解决了如何在 Spring Boot 中使用 JDBC 连接 MySQL 后，我就一直在等，等他问我第三个问题，比如说如何在 Spring Boot 中使用 HikariCP 连接池。但我等了四天也没有等到任何音讯，似乎他从我的世界里消失了，而我却仍然沉醉在他拍我马屁的美妙感觉里。 突然感觉，没有小王的日子里，好空虚。怎么办呢？想来想去还是写文章度日吧，积极创作的过程中，也许能够摆脱对小王的苦苦思念。写什么好呢？ 想来想去，就写如何在 Spring Boot 中使用 HikariCP 连接池吧。
JDBC数据源连接池的配置和使用示例
04-03
本篇文章将详细讲解JDBC数据源连接池的配置和使用，以帮助你更好地理解和应用这一关键技术。 ### 1. 什么是数据源连接池 数据源连接池（DataSource或Connection Pool）是一种管理数据库连接的技术，它预先创建并...
一头扎进JDBC视频教程源码.rar )
06-26
《一头扎进JDBC》系列视频教程源码详解 JDBC（Java Database Connectivity）是Java语言与各种数据库交互的一种标准接口，它允许Java程序通过Java API来操作数据库。本系列视频教程源码提供了从基础到深入的JDBC学习...
Hikaricp源码解读
10-24
深入开源连接池HikariCP，从源码解读HikariCP的速度优势来源！ ps：整理源码版本位v2.7.2
HikariCP JAR包及示例代码
10-29
HikariCP数据库连接池，代号：光，It's Faster。附件是使用HikariCP所需的jar包（HikariCP-2.5.1.jar）及java使用HikariCP的示例代码。
49_传智播客JDBC_所有源码与ppt.rar
03-31
本教程“49_传智播客JDBC_所有源码与ppt.rar”是一个全面的JDBC学习资源包，包含了一系列的源代码示例和配套的PPT讲解，旨在帮助开发者深入理解JDBC的工作原理和应用技巧。 首先，我们要明确JDBC的核心概念。JDBC是...
HikariCP的基本使用和属性详解
beyond丿灬的博客
12-08 1万+
一、主要配置 1、dataSourceClassName 这是DataSourceJDBC驱动程序提供的类的名称。请查阅您的特定JDBC驱动程序的文档以获取此类名称，或参阅下表。注XA数据源不受支持。XA需要像bitronix这样的真正的事务管理器 。请注意，如果您正在使用jdbcUrl“旧式”基于DriverManager的JDBC驱动程序配置，则不需要此属性 。 默认值：无 2、jdbcU...
数据库连接池-HikariCP-配置和使用
roy的专栏
07-07 1万+
1. hikari.properties文件jdbcUrl=jdbc:mysql://localhost:3306/test username=test password=123456 maximumPoolSize=30 minimumIdle=5 connectionTestQuery=SELECT 1 autoCommit=true dataSource.cachePrepStmts=true
hikariCP源码详解
demon7552003的小本本
07-22 945
现在已经有很多公司在使用HikariCP了，HikariCP还成为了SpringBoot默认的连接池，伴随着SpringBoot和微服务，HikariCP 必将迎来广泛的普及。
HikariCP 连接池
codeinglife的博客
05-28 2376
HikariCP 是一个快速、简单、可靠的 JDBC 连接池，在性能上做了很多优化，是目前最快的数据库连接池；本文主要介绍 HikariCP 的基本使用，文中使用到的软件版本：Java 1.8.0_191、HikariCP 4.0.3、Spring Boot 2.3.12.RELEASE。
java之HikariCP连接池介绍和使用方法 简单易懂
weixin_72473547的博客
12-20 2820
在我们的工作中，免不了要和数据库打交道，而要想和数据库打好交道，选择一款合适的数据库连接池就至关重要，我们基本使用的数据库连接池有 c3p0、DBCP、BoneCP、Druid 等，而我们这次要介绍的主角是 HiKariCP，HiKariCP 号称业界跑得最快的数据库连接池，近几年发展的风生水起，更是被 Spring Boot 2.0 选中作为其默认数据库连接池。HiKariCP 全称 HiKari Connection Pool，HiKari 源自日语 - 光。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值