springboot2的hikari数据库连接池默认配置

最新推荐文章于 2024-05-06 08:30:00 发布
最新推荐文章于 2024-05-06 08:30:00 发布
阅读量1.8k 收藏 2
点赞数
文章标签： java 数据库 runtime
原文链接：https://my.oschina.net/go4it/blog/1615322
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

序

Spring-Boot-2.0.0-M1版本将默认的数据库连接池从tomcat jdbc pool改为了hikari，这里主要研究下hikari的默认配置

spring-configuration-metadata.json

spring-boot-autoconfigure-2.0.0.M7.jar!/META-INF/spring-configuration-metadata.json

  	{
      "sourceType": "org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration$Hikari",
      "name": "spring.datasource.hikari",
      "sourceMethod": "dataSource(org.springframework.boot.autoconfigure.jdbc.DataSourceProperties)",
      "type": "com.zaxxer.hikari.HikariDataSource"
    },
  	{
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.allow-pool-suspension",
      "type": "java.lang.Boolean"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.auto-commit",
      "type": "java.lang.Boolean"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.catalog",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.connection-init-sql",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.connection-test-query",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.connection-timeout",
      "type": "java.lang.Long"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.data-source-class-name",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.data-source-j-n-d-i",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.data-source-properties",
      "type": "java.util.Properties"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.driver-class-name",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.health-check-properties",
      "type": "java.util.Properties"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.health-check-registry",
      "type": "java.lang.Object"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.idle-timeout",
      "type": "java.lang.Long"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "deprecated": true,
      "name": "spring.datasource.hikari.initialization-fail-fast", //initializationFailTimeout > 0
      "type": "java.lang.Boolean",
      "deprecation": {}
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.initialization-fail-timeout",
      "type": "java.lang.Long"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.isolate-internal-queries",
      "type": "java.lang.Boolean"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.jdbc-url",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "deprecated": true,
      "name": "spring.datasource.hikari.jdbc4-connection-test", //废弃
      "type": "java.lang.Boolean",
      "deprecation": {}
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.leak-detection-threshold",
      "type": "java.lang.Long"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.login-timeout", //在HikariDataSource及PoolBase中
      "type": "java.lang.Integer"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.max-lifetime",
      "type": "java.lang.Long"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.maximum-pool-size",
      "type": "java.lang.Integer"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.metric-registry",
      "type": "java.lang.Object"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.metrics-tracker-factory",
      "type": "com.zaxxer.hikari.metrics.MetricsTrackerFactory"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.minimum-idle",
      "type": "java.lang.Integer"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.password",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.pool-name",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.read-only",
      "type": "java.lang.Boolean"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.register-mbeans",
      "type": "java.lang.Boolean"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.scheduled-executor",
      "type": "java.util.concurrent.ScheduledExecutorService"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "deprecated": true,
      "name": "spring.datasource.hikari.scheduled-executor-service",
      "type": "java.util.concurrent.ScheduledThreadPoolExecutor",
      "deprecation": {}
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.schema",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.transaction-isolation", //transactionIsolationName
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.username",
      "type": "java.lang.String"
    },
    {
      "sourceType": "com.zaxxer.hikari.HikariDataSource",
      "name": "spring.datasource.hikari.validation-timeout",
      "type": "java.lang.Long"
    },

HikariConfig

HikariCP-2.7.6-sources.jar!/com/zaxxer/hikari/HikariConfig.java

@SuppressWarnings({"SameParameterValue", "unused"})
public class HikariConfig implements HikariConfigMXBean
{
   private static final Logger LOGGER = LoggerFactory.getLogger(HikariConfig.class);

   private static final char[] ID_CHARACTERS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
   private static final long CONNECTION_TIMEOUT = SECONDS.toMillis(30);
   private static final long VALIDATION_TIMEOUT = SECONDS.toMillis(5);
   private static final long IDLE_TIMEOUT = MINUTES.toMillis(10);
   private static final long MAX_LIFETIME = MINUTES.toMillis(30);
   private static final int DEFAULT_POOL_SIZE = 10;
   //......

   /**
    * Default constructor
    */
   public HikariConfig()
   {
      dataSourceProperties = new Properties();
      healthCheckProperties = new Properties();

      minIdle = -1;
      maxPoolSize = -1;
      maxLifetime = MAX_LIFETIME;
      connectionTimeout = CONNECTION_TIMEOUT;
      validationTimeout = VALIDATION_TIMEOUT;
      idleTimeout = IDLE_TIMEOUT;
      initializationFailTimeout = 1;
      isAutoCommit = true;

      String systemProp = System.getProperty("hikaricp.configurationFile");
      if (systemProp != null) {
         loadProperties(systemProp);
      }
   }

   @Override
   public void setConnectionTimeout(long connectionTimeoutMs)
   {
      if (sealed) throw new IllegalStateException("The configuration of the pool is sealed once started.  Use HikariConfigMXBean for runtime changes.");

      if (connectionTimeoutMs == 0) {
         this.connectionTimeout = Integer.MAX_VALUE;
      }
      else if (connectionTimeoutMs < 250) {
         throw new IllegalArgumentException("connectionTimeout cannot be less than 250ms");
      }
      else {
         this.connectionTimeout = connectionTimeoutMs;
      }
   }

   @Override
   public void setIdleTimeout(long idleTimeoutMs)
   {
      if (sealed) throw new IllegalStateException("The configuration of the pool is sealed once started.  Use HikariConfigMXBean for runtime changes.");

      if (idleTimeoutMs < 0) {
         throw new IllegalArgumentException("idleTimeout cannot be negative");
      }
      this.idleTimeout = idleTimeoutMs;
   }

   @Override
   public void setMaximumPoolSize(int maxPoolSize)
   {
      if (sealed) throw new IllegalStateException("The configuration of the pool is sealed once started.  Use HikariConfigMXBean for runtime changes.");

      if (maxPoolSize < 1) {
         throw new IllegalArgumentException("maxPoolSize cannot be less than 1");
      }
      this.maxPoolSize = maxPoolSize;
   }

   @Override
   public void setMinimumIdle(int minIdle)
   {
      if (sealed) throw new IllegalStateException("The configuration of the pool is sealed once started.  Use HikariConfigMXBean for runtime changes.");

      if (minIdle < 0) {
         throw new IllegalArgumentException("minimumIdle cannot be negative");
      }
      this.minIdle = minIdle;
   }

   @Override
   public void setValidationTimeout(long validationTimeoutMs)
   {
      if (sealed) throw new IllegalStateException("The configuration of the pool is sealed once started.  Use HikariConfigMXBean for runtime changes.");

      if (validationTimeoutMs < 250) {
         throw new IllegalArgumentException("validationTimeout cannot be less than 250ms");
      }

      this.validationTimeout = validationTimeoutMs;
   }

   public void validate()
   {
      if (poolName == null) {
         poolName = generatePoolName();
      }
      else if (isRegisterMbeans && poolName.contains(":")) {
         throw new IllegalArgumentException("poolName cannot contain ':' when used with JMX");
      }

      // treat empty property as null
      catalog = getNullIfEmpty(catalog);
      connectionInitSql = getNullIfEmpty(connectionInitSql);
      connectionTestQuery = getNullIfEmpty(connectionTestQuery);
      transactionIsolationName = getNullIfEmpty(transactionIsolationName);
      dataSourceClassName = getNullIfEmpty(dataSourceClassName);
      dataSourceJndiName = getNullIfEmpty(dataSourceJndiName);
      driverClassName = getNullIfEmpty(driverClassName);
      jdbcUrl = getNullIfEmpty(jdbcUrl);

      // Check Data Source Options
      if (dataSource != null) {
         if (dataSourceClassName != null) {
            LOGGER.warn("{} - using dataSource and ignoring dataSourceClassName.", poolName);
         }
      }
      else if (dataSourceClassName != null) {
         if (driverClassName != null) {
            LOGGER.error("{} - cannot use driverClassName and dataSourceClassName together.", poolName);
            // NOTE: This exception text is referenced by a Spring Boot FailureAnalyzer, it should not be
            // changed without first notifying the Spring Boot developers.
            throw new IllegalStateException("cannot use driverClassName and dataSourceClassName together.");
         }
         else if (jdbcUrl != null) {
            LOGGER.warn("{} - using dataSourceClassName and ignoring jdbcUrl.", poolName);
         }
      }
      else if (jdbcUrl != null || dataSourceJndiName != null) {
         // ok
      }
      else if (driverClassName != null) {
         LOGGER.error("{} - jdbcUrl is required with driverClassName.", poolName);
         throw new IllegalArgumentException("jdbcUrl is required with driverClassName.");
      }
      else {
         LOGGER.error("{} - dataSource or dataSourceClassName or jdbcUrl is required.", poolName);
         throw new IllegalArgumentException("dataSource or dataSourceClassName or jdbcUrl is required.");
      }

      validateNumerics();

      if (LOGGER.isDebugEnabled() || unitTest) {
         logConfiguration();
      }
   }

   private void validateNumerics()
   {
      if (maxLifetime != 0 && maxLifetime < SECONDS.toMillis(30)) {
         LOGGER.warn("{} - maxLifetime is less than 30000ms, setting to default {}ms.", poolName, MAX_LIFETIME);
         maxLifetime = MAX_LIFETIME;
      }

      if (idleTimeout + SECONDS.toMillis(1) > maxLifetime && maxLifetime > 0) {
         LOGGER.warn("{} - idleTimeout is close to or more than maxLifetime, disabling it.", poolName);
         idleTimeout = 0;
      }

      if (idleTimeout != 0 && idleTimeout < SECONDS.toMillis(10)) {
         LOGGER.warn("{} - idleTimeout is less than 10000ms, setting to default {}ms.", poolName, IDLE_TIMEOUT);
         idleTimeout = IDLE_TIMEOUT;
      }

      if (leakDetectionThreshold > 0 && !unitTest) {
         if (leakDetectionThreshold < SECONDS.toMillis(2) || (leakDetectionThreshold > maxLifetime && maxLifetime > 0)) {
            LOGGER.warn("{} - leakDetectionThreshold is less than 2000ms or more than maxLifetime, disabling it.", poolName);
            leakDetectionThreshold = 0;
         }
      }

      if (connectionTimeout < 250) {
         LOGGER.warn("{} - connectionTimeout is less than 250ms, setting to {}ms.", poolName, CONNECTION_TIMEOUT);
         connectionTimeout = CONNECTION_TIMEOUT;
      }

      if (validationTimeout < 250) {
         LOGGER.warn("{} - validationTimeout is less than 250ms, setting to {}ms.", poolName, VALIDATION_TIMEOUT);
         validationTimeout = VALIDATION_TIMEOUT;
      }

      if (maxPoolSize < 1) {
         maxPoolSize = (minIdle <= 0) ? DEFAULT_POOL_SIZE : minIdle;
      }

      if (minIdle < 0 || minIdle > maxPoolSize) {
         minIdle = maxPoolSize;
      }
   }
}

可以看到在set方法添加了参数校验，同时在configuration的构造器以及getConnection方法中也调用了validate方法

   public HikariDataSource(HikariConfig configuration)
   {
      configuration.validate();
      configuration.copyStateTo(this);
      this.seal();

      LOGGER.info("{} - Starting...", configuration.getPoolName());
      pool = fastPathPool = new HikariPool(this);
      LOGGER.info("{} - Start completed.", configuration.getPoolName());
   }

   /** {@inheritDoc} */
   @Override
   public Connection getConnection() throws SQLException
   {
      if (isClosed()) {
         throw new SQLException("HikariDataSource " + this + " has been closed.");
      }

      if (fastPathPool != null) {
         return fastPathPool.getConnection();
      }

      // See http://en.wikipedia.org/wiki/Double-checked_locking#Usage_in_Java
      HikariPool result = pool;
      if (result == null) {
         synchronized (this) {
            result = pool;
            if (result == null) {
               validate();
               LOGGER.info("{} - Starting...", getPoolName());
               try {
                  pool = result = new HikariPool(this);
                  this.seal();
               }
               catch (PoolInitializationException pie) {
                  if (pie.getCause() instanceof SQLException) {
                     throw (SQLException) pie.getCause();
                  }
                  else {
                     throw pie;
                  }
               }
               LOGGER.info("{} - Start completed.", getPoolName());
            }
         }
      }

      return result.getConnection();
   }

springboot的autoconfig是采用BeanUtils的反射来初始化HikariDataSource，走的是默认构造器，因此校验就依赖set方法以及后续的getConnection方法。

PoolBase.setLoginTimeout

HikariCP-2.7.6-sources.jar!/com/zaxxer/hikari/pool/PoolBase.java

   /**
    * Set the loginTimeout on the specified DataSource.
    *
    * @param dataSource the DataSource
    */
   private void setLoginTimeout(final DataSource dataSource)
   {
      if (connectionTimeout != Integer.MAX_VALUE) {
         try {
            dataSource.setLoginTimeout(Math.max(1, (int) MILLISECONDS.toSeconds(500L + connectionTimeout)));
         }
         catch (Throwable e) {
            LOGGER.info("{} - Failed to set login timeout for data source. ({})", poolName, e.getMessage());
         }
      }
   }

这个在初始化的时候设定了loginTimeout，初始值为Math.max(1, (int) MILLISECONDS.toSeconds(500L + connectionTimeout))

小结

springboot的HikariDataSource默认配置的默认值如下

name构造器默认值默认配置validate之后的值validate重置
minIdle-110minIdle<0或者minIdle>maxPoolSize,则被重置为maxPoolSize
maxPoolSize-110如果maxPoolSize小于1，则会被重置。当minIdle<=0被重置为DEFAULT_POOL_SIZE则为10;如果minIdle>0则重置为minIdle的值
maxLifetimeMINUTES.toMillis(30) = 18000001800000如果不等于0且小于30秒则会被重置回30分钟
connectionTimeoutSECONDS.toMillis(30) = 3000030000如果小于250毫秒，则被重置回30秒
validationTimeoutSECONDS.toMillis(5) = 50005000如果小于250毫秒，则会被重置回5秒
loginTimeout1030Math.max(1, (int) MILLISECONDS.toSeconds(500L + connectionTimeout))，为connectionTimeout+500ms转为秒数取整 与 1 取最大者
idleTimeoutMINUTES.toMillis(10) = 600000600000如果idleTimeout+1秒>maxLifetime 且 maxLifetime>0，则会被重置为0；如果idleTimeout!=0且小于10秒，则会被重置为10秒
leakDetectionThreshold00如果大于0且不是单元测试，则进一步判断：(leakDetectionThreshold < SECONDS.toMillis(2) or (leakDetectionThreshold > maxLifetime && maxLifetime > 0)，会被重置为0 . 即如果要生效则必须>0，而且不能小于2秒，而且当maxLifetime > 0时不能大于maxLifetime
initializationFailTimeout11-
isAutoCommittruetrue-
isReadOnlyfalsefasle-
isAllowPoolSuspensionfalsefalse-
isIsolateInternalQueriesfalsefalse-
isRegisterMbeansfalsefalse-
sealedfalsetrue运行启动后这个标志为true，表示不再运行修改
poolNamenullHikariPool-1-
catalognullnull-
connectionInitSqlnullnull-
connectionTestQuerynullnull-
dataSourceClassNamenullnull-
schemanullnull-
transactionIsolationNamenullnull-
dataSourcenullnull-
dataSourceProperties{}{}-
threadFactorynullnull-
scheduledExecutornullnull-
metricsTrackerFactorynullnull-
metricRegistrynullnull-
healthCheckRegistrynullnull-
healthCheckProperties{}{}-

doc

转载于:https://my.oschina.net/go4it/blog/1615322

weixin_34399060
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于使用spring.datasource.hikari连接数据库找不到找不到url的问题
qq_40791070的博客
09-08 4991
关于使用spring.datasource.hikari连接数据库找不到找不到url的问题applica.properties里配置连接数据库使用hikari出现的问题异常解决 配置重定义识别数据库连接方式为spring.datasource.primary完美解决 applica.properties里配置连接数据库使用hikari #链接数据库 spring.datasource.primar...
HikariCP连接池配置
qq_42782063的博客
05-29 2289
HikariCP 连接池 连接hikari数据源 spring.datasource.type=com.zaxxer.hikari.HikariDataSource 数据库连接地址 spring.datasource.hikari.jdbc-url= 数据库账户，如果使用了jdbcUrl则需要此属性 spring.datasource.hikari....
连接池配置你真的会吗？
JavaEdge全是干货的技术号
03-22 1359
连接池配置 连接池提供了许多参数，最重要的就是最大连接数，连接池能使用的连接数达到上限后，新来的请求需要等待其他请求释放连接。 最大连接数不是越大越好： 过大 客户端需耗费过多资源维护连接，且由于服务端对应的是多个客户端，每一个客户端都保持大量连接，会给服务端带来更大压力：不仅是内存压力，若服务端的网络模型是一个TCP连接一个线程，那么几千个连接意味着几千个线程，导致大量线程切换开销 过小 可能因为获取连接的等待时间太长，导致吞吐量低下，甚至超时无法获取连接 模拟压力增大导致数据库连接池打满 如何确认连
springBoot + Hikari 配置多数据源连接数据库
xgb2018的博客
03-01 9950
springBoot + Hikari 配置多数据源连接数据库
Spring Boot——数据库连接池配置
最新发布
程序员阿皓的博客
05-06 919
Spring Boot默认使用HikariCP作为数据库连接池，可以通过配置文件对其进行调整。
Springboot空项目启动时报错
voidL123的博客
12-06 6785
Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'inMemoryDatabaseShut...
Spring Boot中配置默认的HikariCP数据源
好看的皮囊千篇一律，有趣的灵魂万里挑一。
10-30 4170
HikariCP是一个高性能的JDBC（Java数据库连接）连接池库，用于管理数据库连接的分配和释放。它旨在提供快速、轻量级和可伸缩的数据库连接池，特别适用于Java应用程序，如Spring Boot应用程序。 HikariCP的主要特点包括： 1. **高性能**： HikariCP的设计目标之一是提供卓越的性能。它通过减少连接池本身的开销、优化线程池的管理以及有效地处理数据库连接的分配和释放来实现高性能。 2. **轻量级**： HikariCP是一个轻量级的库，它的jar文件非常小，不会占
hikaripool连接保持_springboot2的hikari数据库连接池默认配置
weixin_31967551的博客
02-15 1521
序Spring-Boot-2.0.0-M1版本将默认的数据库连接池从tomcat jdbc pool改为了hikari，这里主要研究下hikari的默认配置spring-configuration-metadata.jsonspring-boot-autoconfigure-2.0.0.M7.jar!/META-INF/spring-configuration-metadata.json{"sou...
spring mysql 连接池配置_SpringBoot数据库连接池常用配置
weixin_29689845的博客
02-04 1812
关注公众号：程序猿王国 持续更新，每日分享在配置文件中添加配置如下(我使用的是多数据源)：spring.datasource.primary.url=jdbc\:mysql\://localhost\:3306/test?useUnicode\=true&characterEncoding\=utf-8spring.datasource.primary.username=t...
springboot2.0使用Hikari连接池的方法（替换druid）
08-25
在Spring Boot 2.0中，开发者们可以选择多种数据库连接池实现，而HikariCP是默认推荐的连接池。相较于Druid，HikariCP以其高性能和低延迟获得了广泛认可。本文将详细介绍如何在Spring Boot 2.0项目中使用HikariCP...
详解SpringBoot配置连接池
08-30
总之，SpringBoot通过自动配置使得数据库连接池的配置变得简单，而Druid作为一款强大的连接池组件，提供了丰富的监控和扩展功能，是很多开发者的选择。通过合理配置，我们可以有效管理和优化数据库连接，提高应用的...
springboot中注解配置连接池
06-04
首先，Spring Boot默认集成了多种数据库连接池，如HikariCP、Tomcat JDBC Pool和DBCP2等。其中，HikariCP因其高性能和稳定性而被广泛推荐。我们可以使用`spring-boot-starter-jdbc`或特定数据源的starter（如`spring...
Spring Boot如何使用HikariCP连接池详解
08-26
Spring Boot 2.x版本默认采用HikariCP作为其数据连接池，因为HikariCP以其高效和高性能著称。HikariCP通过使用Javassist库进行字节码操作，提高了性能，并使用了如FastList和ConcurrentBag等特殊集合类，以优化并发...
SpringBoot集成MybatisPlus, Redis,hikari ,swagger2
11-23
在本项目中，我们主要关注的是SpringBoot框架与MybatisPlus、Redis、Hikari以及Swagger2的集成。这些技术都是现代Java开发中常用且重要的组件，它们在实际项目中的应用广泛，对于提升开发效率和优化系统性能有着显著...
spring.datasource.url与spring.datasource.jdbc-url
m0_67392931的博客
08-24 2572
因为连接池的实际类型没有被公开，所以在您的自定义数据源的元数据中没有生成密钥，而且在IDE中没有完成(因为DataSource接口没有暴露属性)。另外，如果您碰巧在类路径上有Hikari，那么这个基本设置就不起作用了，因为Hikari没有url属性(但是确实有一个jdbcUrl属性)。spring.datasource.jdbc-url 用来创建连接的 JDBC URL。上网搜了一下，结果是使用app.datasource.url的锅。今天使用spring boot配置两个数据源，出现了问题。
SpringBoot启动时报错：The bean 'dataSource', defined in BeanDefinition defined in class path resource
j10000001的博客
05-10 4632
SpringBoot启动时报错： The bean 'dataSource', defined in BeanDefinition defined in class path resource [org/springframework/boot/autoconfigure/jdbc/DataSourceConfiguration$Hikari.class], could not be registered. A bean with that name has already been defined in
spring-boot2项目默认hikari数据源的配置
婉约派程序员
03-21 3552
spring-boot2中默认使用hikari连接池管理数据源链接。下面列出了项目中配置的内容，也是项目中常用的配置项，基本就够用了。 首先配置数据源： # spring datasource配置 spring.datasource.driverClassName=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://www.kev...
springboot自带hikari数据源的使用
qq_51863442的博客
10-18 1330
以下是基于properties文件进行配置，此数据源不同Druid，C3P0等，无需导入依赖 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf-8 spring.datasource.username=root spring.datasource.
SpringBoot数据库连接池Hikari配置
热门推荐
fly_duck的博客
11-17 2万+
在项目中，一般情况下访问数据库，会创建一个连接，用完后就关闭它，对于简单的系统这样不会带来什么明显的性能上的开销。但是对于一个复杂的系统，频繁的建立、关闭连接，会极大的减低系统的性能，因为对于数据库连接的使用可能会成为系统性能的瓶颈。数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。 SpringBoot默认使用Hikari SpringBoot项目如果
如何查看springboot项目中数据库连接池的信息
08-20
1. 打开Spring Boot项目的配置文件application.properties（或application.yml），查找数据库连接池的相关配置项。 2. 在配置文件中，通常会有以下几个关键的配置项： - spring.datasource.url：数据库连接的URL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值