106

我正在尝试在我的 Spring Boot (1.2.0.M1) 应用程序中设置 HikariCP,以便可以使用它代替 Tomcat DBCP 进行测试。我想在我的 application.properties 文件中配置连接池,就像我对 Tomcat 所做的那样,但我不知道我应该怎么做。我发现的所有示例都显示了 JavaConfig 样式或使用单独的 HikariCP 属性文件。有人可以帮我找出在 application.properties 中配置它的属性名称吗?我还想从使用 driverClassName 方法切换到 DataSourceClassName 方法,因为它看起来更干净并且被推荐。这在我的 application.properties 文件中也可以吗?

这是我对 Tomcat DBCP 所做的(只是一些基本配置,没有完全清除)

spring.datasource.validation-query=SELECT 1
spring.datasource.max-active=10
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=5
spring.datasource.test-on-borrow=true
spring.datasource.test-on-return=true

我目前正在使用 driverClassName 和 jdbc url 来建立连接:

spring.datasource.url=jdbc:mysql://localhost:3306/myDb
spring.datasource.driverClassName=com.mysql.jdbc.Driver
4

18 回答 18

158
@Configuration
@ConfigurationProperties(prefix = "params.datasource")
public class JpaConfig extends HikariConfig {

    @Bean
    public DataSource dataSource() throws SQLException {
        return new HikariDataSource(this);
    }

}

应用程序.yml

params:
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql://localhost:3306/myDb
    username: login
    password: password
    maximumPoolSize: 5

更新!从版本 Spring Boot 1.3.0 开始

  1. 只需将 HikariCP 添加到依赖项
  2. 配置 application.yml

应用程序.yml

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:h2:mem:TEST
    driver-class-name: org.h2.Driver
    username: username
    password: password
    hikari:
      idle-timeout: 10000

更新!从版本 Spring Boot 2.0.0 开始

默认连接池已从 Tomcat 更改为 Hikari :)

于 2015-10-19T11:57:43.867 回答
36

我遇到了HikariCP,我对基准测试感到惊讶,我想尝试它而不是我的默认选择C3P0,令我惊讶的是,我努力获得configurations正确的可能是因为配置因您使用的技术堆栈组合而异。

我已经设置Spring Boot了带有JPA, Web, Security启动器的项目(使用Spring Initializer)以用作具有连接池PostgreSQL的数据库。 我已用作构建工具,我想分享以下假设对我有用的东西:HikariCP
Gradle

  1. Spring Boot Starter JPA(Web 和安全 - 可选)
  2. Gradle 也可以构建
  3. 使用数据库(即模式、用户、数据库)运行和设置 PostgreSQL

如果您正在使用,则需要以下内容build.gradle;如果您正在使用 Maven,则Gradle需要以下内容pom.xml

buildscript {
    ext {
        springBootVersion = '1.5.8.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'

group = 'com'
version = '1.0'
sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile('org.springframework.boot:spring-boot-starter-aop')

    // Exclude the tomcat-jdbc since it's used as default for connection pooling
    // This can also be achieved by setting the spring.datasource.type to HikariCP 
    // datasource see application.properties below
    compile('org.springframework.boot:spring-boot-starter-data-jpa') {
        exclude group: 'org.apache.tomcat', module: 'tomcat-jdbc'
    }
    compile('org.springframework.boot:spring-boot-starter-security')
    compile('org.springframework.boot:spring-boot-starter-web')
    runtime('org.postgresql:postgresql')
    testCompile('org.springframework.boot:spring-boot-starter-test')
    testCompile('org.springframework.security:spring-security-test')

    // Download HikariCP but, exclude hibernate-core to avoid version conflicts
    compile('com.zaxxer:HikariCP:2.5.1') {
        exclude group: 'org.hibernate', module: 'hibernate-core'
    }

    // Need this in order to get the HikariCPConnectionProvider
    compile('org.hibernate:hibernate-hikaricp:5.2.11.Final') {
        exclude group: 'com.zaxxer', module: 'HikariCP'
        exclude group: 'org.hibernate', module: 'hibernate-core'
    }
}

上面有很多排除项,build.gradle那是因为

  1. 首先 exclude,指示 gradle在下载依赖项jdbc-tomcat时排除连接池。spring-boot-starter-data-jpa这可以通过设置也来实现,spring.datasource.type=com.zaxxer.hikari.HikariDataSource但是,如果我不需要它,我不想要额外的依赖
  2. 第二个排除,指示 gradlehibernate-core在下载com.zaxxer依赖项时排除,这是因为hibernate-core已经下载Spring Boot,我们不希望最终得到不同的版本。
  3. 第三个排除,指示 gradlehibernate-core在下载hibernate-hikaricp模块时排除,以使 HikariCPorg.hibernate.hikaricp.internal.HikariCPConnectionProvider用作连接提供程序而不是弃用com.zaxxer.hikari.hibernate.HikariConnectionProvider

一旦我弄清楚了build.gradle要保留的内容和不保留的内容,我就准备将配置复制/粘贴datasource到我的配置application.properties中,并希望一切都能顺利进行,但事实并非如此,我偶然发现了以下问题

  • Spring boot 无法找到数据库详细信息(即 url、驱动程序),因此无法设置 jpa 和 hibernate(因为我没有正确命名属性键值)
  • HikariCP 回落到com.zaxxer.hikari.hibernate.HikariConnectionProvider
  • 在指示 Spring 在自动配置 hibernate/jpa 时使用新的连接提供程序之后,HikariCP 失败了,因为它正在寻找一些key/valueapplication.properties抱怨dataSource, dataSourceClassName, jdbcUrl. 我不得不调试HikariConfig, HikariConfigurationUtil, HikariCPConnectionProvider并发现HikariCP无法找到属性,application.properties因为它的名称不同。

无论如何,这是我不得不依靠反复试验并确保HikariCP能够选择属性(即,数据库详细信息的数据源以及池属性)以及 Sping Boot 的行为的地方,我最终得到了以下application.properties文件。

server.contextPath=/
debug=true

# Spring data source needed for Spring boot to behave
# Pre Spring Boot v2.0.0.M6 without below Spring Boot defaults to tomcat-jdbc connection pool included 
# in spring-boot-starter-jdbc and as compiled dependency under spring-boot-starter-data-jpa
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.url=jdbc:postgresql://localhost:5432/somedb
spring.datasource.username=dbuser
spring.datasource.password=dbpassword

# Hikari will use the above plus the following to setup connection pooling
spring.datasource.hikari.minimumIdle=5
spring.datasource.hikari.maximumPoolSize=20
spring.datasource.hikari.idleTimeout=30000
spring.datasource.hikari.poolName=SpringBootJPAHikariCP
spring.datasource.hikari.maxLifetime=2000000
spring.datasource.hikari.connectionTimeout=30000

# Without below HikariCP uses deprecated com.zaxxer.hikari.hibernate.HikariConnectionProvider
# Surprisingly enough below ConnectionProvider is in hibernate-hikaricp dependency and not hibernate-core
# So you need to pull that dependency but, make sure to exclude it's transitive dependencies or you will end up 
# with different versions of hibernate-core 
spring.jpa.hibernate.connection.provider_class=org.hibernate.hikaricp.internal.HikariCPConnectionProvider

# JPA specific configs
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql=true
spring.jpa.properties.hibernate.id.new_generator_mappings=false
spring.jpa.properties.hibernate.default_schema=dbschema
spring.jpa.properties.hibernate.search.autoregister_listeners=false
spring.jpa.properties.hibernate.bytecode.use_reflection_optimizer=false

# Enable logging to verify that HikariCP is used, the second entry is specific to HikariCP
logging.level.org.hibernate.SQL=DEBUG
logging.level.com.zaxxer.hikari.HikariConfig=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE 

如上所示,配置根据以下命名模式分为几类

  • spring.datasource.x(Spring 自动配置会选择这些,HikariCP 也会选择)
  • spring.datasource.hikari.x(HikariCP 选择这些来设置池,记下 camelCase 字段名称)
  • spring.jpa.hibernate.connection.provider_class(指示 Spring 使用新的 HibernateConnectionProvider)
  • spring.jpa.properties.hibernate.x(由 Spring 用于自动配置 JPA,用下划线记下字段名称)

很难找到说明如何使用上述属性文件以及如何命名属性的教程或帖子或某些资源。好吧,你有它。

将上述内容application.propertiesbuild.gradle(或至少类似)放入 Spring Boot JPA 项目版本(1.5.8)应该像魅力一样工作并连接到您预先配置的数据库(即在我的情况下,它是 PostgreSQL,两者都HikariCP & Springspring.datasource.url要使用的数据库驱动程序)。

我没有看到创建DataSourcebean 的必要性,那是因为 Spring Boot 只需查看即可为我做所有事情,application.properties这很整洁。

HikariCP 的 github wiki中的文章展示了如何使用 JPA 设置 Spring Boot,但缺乏解释和细节。

上述两个文件也可作为公共要点https://gist.github.com/rhamedy/b3cb936061cc03acdfe21358b86a5bc6

于 2017-11-12T06:12:50.360 回答
26

您可以只使用 application.yml/application.properties。无需显式创建任何DataSourceBean

您需要排除 ydemartino 提到的 tomcat-jdbc

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jdbc</artifactId>
        </exclusion>
    </exclusions>
</dependency>

由于您不会创建bean,因此您必须通过application.yml / application.properties 中的 valueDataSource明确指定使用 Hikarispring.datasource.typecom.zaxxer.hikari.HikariDataSource

spring:
    datasource:
        hikari:
            connection-test-query: SELECT 1 FROM DUAL
            minimum-idle: 1
            maximum-pool-size: 5
            pool-name: yourPoolName
            auto-commit: false
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/myDb
        username: login
        password: password
        type: com.zaxxer.hikari.HikariDataSource

在您的 application.yml / application.properties 中,您可以配置 Hikari 特定参数,例如池大小等spring.datasource.hikari.*

于 2016-08-10T05:06:10.010 回答
17

我正在使用 Spring Boot 2.0.4.RELEASE。Hikari 是默认连接池,.hikari不再需要。

应用程序属性

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.jdbcUrl=jdbc:mysql://localhost:3306/myDB...
spring.datasource.username=xxx
spring.datasource.password=xxx
spring.datasource.poolname=myPool

应用程序.yml

spring:
    datasource:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/myDB...
        username: xxx
        password: xxx
        poolName: myPool

并且configuration不需要扩展HikariConfigDataSourceBuilder可以像以前一样使用。

@Configuration
public class DataSourceConfiguration {

    @Bean(name="myDataSource")
    @ConfigurationProperties("spring.datasource")
    public DataSource myDataSource() {
        return DataSourceBuilder.create().build();
    }
}
于 2018-09-14T07:21:44.877 回答
11

您不需要多余的代码来将属性值放入变量中。您可以直接使用属性文件设置属性。

hikari.properties文件放在类路径中。

driverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/myDb
connectionTestQuery=SELECT 1
maximumPoolSize=20
username=...
password=...

并像这样制作一个数据源bean。

@Bean(destroyMethod = "close")
public DataSource dataSource() throws SQLException {
    HikariConfig config = new HikariConfig("/hikari.properties");
    HikariDataSource dataSource = new HikariDataSource(config);

    return dataSource;
}
于 2015-08-19T10:32:38.930 回答
10

根据文档,它已更改,

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html

例子 :

spring:
    datasource:
        url: 'jdbc:mysql://localhost/db?useSSL=false'
        username: root
        password: pass
        driver: com.mysql.jdbc.Driver
        hikari:
            minIdle: 10
            idle-timeout: 10000
            maximumPoolSize: 30

这些是我们可以在 hikari 上进行的以下配置更改,请根据您的需要添加/更新。

autoCommit
connectionTimeout
idleTimeout
maxLifetime
connectionTestQuery
connectionInitSql
validationTimeout
maximumPoolSize
poolName
allowPoolSuspension
readOnly
transactionIsolation
leakDetectionThreshold
于 2018-06-28T09:24:47.320 回答
10

这将帮助任何想要使用 spring 自动配置为其应用程序配置 hikaricp 的人。对于我的项目,我使用带有 hikaricp 作为 JDBC 连接池和 mysql 作为数据库的 spring boot 2。我在其他答案中没有看到的一件事是data-source-properties可用于设置spring.datasource.hikari.*路径中不可用的各种属性。这相当于使用HikariConfig类。为了为 mysql 特定属性配置数据源和 hikaricp 连接池,我在 application.yml 文件中使用了 spring auto configure 注释和以下属性。

放置@EnableAutoConfiguration在您的配置 bean 文件之一上。

application.yml文件看起来像这样。

spring:
  datasource:
    url: 'jdbc:mysql://127.0.0.1:3306/DATABASE?autoReconnect=true&useSSL=false'
    username: user_name
    password: password
    hikari:
      maximum-pool-size: 20
      data-source-properties:
        cachePrepStmts: true
        prepStmtCacheSize: 250
        prepStmtCacheSqlLimit: 2048
        useServerPrepStmts: true
        useLocalSessionState: true
        rewriteBatchedStatements: true
        cacheResultSetMetadata: true
        cacheServerConfiguration: true
        elideSetAutoCommits: true
        maintainTimeStats: false
于 2019-02-08T20:38:14.583 回答
9

这适用于我的启动应用程序,以防万一。此类告诉您配置对象正在寻找哪些属性:

https://github.com/brettwooldridge/HikariCP/blob/2.3.x/hikaricp-common/src/main/java/com/zaxxer/hikari/AbstractHikariConfig.java

我认为可以通过添加datasource_whatever到源配置文件中的属性键来支持多个数据源。干杯!

@Configuration
class DataSourceConfig {

   @Value('${spring.datasource.username}')
   private String user;

   @Value('${spring.datasource.password}')
   private String password;

   @Value('${spring.datasource.url}')
   private String dataSourceUrl;

   @Value('${spring.datasource.dataSourceClassName}')
   private String dataSourceClassName;

   @Value('${spring.datasource.connectionTimeout}')
   private int connectionTimeout;

   @Value('${spring.datasource.maxLifetime}')
   private int maxLifetime;

   @Bean
   public DataSource primaryDataSource() {
      Properties dsProps = [url: dataSourceUrl, user: user, password: password]
      Properties configProps = [
            connectionTestQuery: 'select 1 from dual',
            connectionTimeout: connectionTimeout,
            dataSourceClassName: dataSourceClassName,
            dataSourceProperties: dsProps,
            maxLifetime: maxLifetime
      ]

      // A default max pool size of 10 seems reasonable for now, so no need to configure for now.
      HikariConfig hc = new HikariConfig(configProps)
      HikariDataSource ds = new HikariDataSource(hc)
      ds
   }
}
于 2015-02-10T19:01:20.983 回答
8

正如@Andy Wilkinson 所说,您不能在 application.properties 配置中使用 dataSourceClassName 方法。如果你想拥有 dataSourceClassName ,你可以使用 Java Config 作为:

@Configuration
@ComponentScan
class DataSourceConfig {

 @Value("${spring.datasource.username}")
private String user;

@Value("${spring.datasource.password}")
private String password;

@Value("${spring.datasource.url}")
private String dataSourceUrl;

@Value("${spring.datasource.dataSourceClassName}")
private String dataSourceClassName;

@Value("${spring.datasource.poolName}")
private String poolName;

@Value("${spring.datasource.connectionTimeout}")
private int connectionTimeout;

@Value("${spring.datasource.maxLifetime}")
private int maxLifetime;

@Value("${spring.datasource.maximumPoolSize}")
private int maximumPoolSize;

@Value("${spring.datasource.minimumIdle}")
private int minimumIdle;

@Value("${spring.datasource.idleTimeout}")
private int idleTimeout;

@Bean
public DataSource primaryDataSource() {
    Properties dsProps = new Properties();
    dsProps.put("url", dataSourceUrl);
    dsProps.put("user", user);
    dsProps.put("password", password);
    dsProps.put("prepStmtCacheSize",250);
    dsProps.put("prepStmtCacheSqlLimit",2048);
    dsProps.put("cachePrepStmts",Boolean.TRUE);
    dsProps.put("useServerPrepStmts",Boolean.TRUE);

    Properties configProps = new Properties();
       configProps.put("dataSourceClassName", dataSourceClassName);
       configProps.put("poolName",poolName);
       configProps.put("maximumPoolSize",maximumPoolSize);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("minimumIdle",minimumIdle);
       configProps.put("connectionTimeout", connectionTimeout);
       configProps.put("idleTimeout", idleTimeout);
       configProps.put("dataSourceProperties", dsProps);

   HikariConfig hc = new HikariConfig(configProps);
   HikariDataSource ds = new HikariDataSource(hc);
   return ds;
   }
  } 

不能使用 dataSourceClassName 的原因,因为它会抛出异常

Caused by: java.lang.IllegalStateException: both driverClassName and dataSourceClassName are specified, one or the other should be used.

这意味着 spring boot 从 spring.datasource.url 属性推断驱动程序,同时设置 dataSourceClassName 会创建此异常。为了使它正确,您的 application.properties 对于 HikariCP 数据源应该看起来像这样:

# hikariCP 
  spring.jpa.databasePlatform=org.hibernate.dialect.MySQLDialect
  spring.datasource.url=jdbc:mysql://localhost:3306/exampledb
  spring.datasource.username=root
  spring.datasource.password=
  spring.datasource.poolName=SpringBootHikariCP
  spring.datasource.maximumPoolSize=5
  spring.datasource.minimumIdle=3
  spring.datasource.maxLifetime=2000000
  spring.datasource.connectionTimeout=30000
  spring.datasource.idleTimeout=30000
  spring.datasource.pool-prepared-statements=true
  spring.datasource.max-open-prepared-statements=250

注意:请检查您的类路径中是否有任何tomcat-jdbc.jar 或commons-dbcp.jar 大部分时间通过传递依赖添加。如果这些存在于类路径中,Spring Boot 将使用默认连接池(即 tomcat)配置数据源。如果类路径中没有其他提供者,HikariCP 将仅用于创建数据源。有一个从 tomcat -> 到 HikariCP -> 到 Commons DBCP 的后备序列。

于 2015-08-01T06:34:09.783 回答
8

您可以使用 dataSourceClassName 方法,这里是 MySQL 的示例。(使用 spring boot 1.3 和 1.4 测试)

首先,您需要从类路径中排除 tomcat-jdbc,因为它将被选中以支持 hikaricp。

pom.xml

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.apache.tomcat</groupId>
                <artifactId>tomcat-jdbc</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

应用程序属性

spring.datasource.dataSourceClassName=com.mysql.jdbc.jdbc2.optional.MysqlDataSource
spring.datasource.dataSourceProperties.serverName=localhost
spring.datasource.dataSourceProperties.portNumber=3311
spring.datasource.dataSourceProperties.databaseName=mydb
spring.datasource.username=root
spring.datasource.password=root

然后只需添加

@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
    return DataSourceBuilder.create().build();
}

我在这里创建了一个测试项目:https ://github.com/ydemartino/spring-boot-hikaricp

于 2016-03-29T14:27:38.103 回答
7

这是好消息。HikariCP 是 Spring Boot 2.0.0 现在的默认连接池。

Spring Boot 2.0.0 发行说明

Spring Boot 2.0 中默认的数据库池技术已从 Tomcat Pool 切换到 HikariCP。我们发现 Hakari 提供了卓越的性能,我们的许多用户更喜欢它而不是 Tomcat Pool。

于 2018-02-28T19:34:38.703 回答
6

所以事实证明,除了数据库连接数之外,几乎所有 HikariCP 的默认设置都对我有用。我在 application.properties 中设置了该属性:

spring.datasource.maximumPoolSize=20

据我所知,Andy Wilkinson 是正确的,因为您不能在 Spring Boot 中使用 HikariCP 的 dataSourceClassName 配置方法。

于 2014-10-22T18:44:04.570 回答
3

我的设置:
Spring Boot v1.5.10
Hikari v.3.2.x(用于评估)

要真正了解 Hikari Data Source 的配置,我建议禁用 Spring Boot 的 Auto-Configuration for Data Source。

将以下内容添加到 application.properties:-

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

这将禁用 Spring Boot 自行配置 DataSource 的功能。

现在是您定义自己的自定义配置以创建 HikariDataSource bean 并使用所需属性填充它的机会。

注意 :::
公共类 HikariDataSource 扩展 HikariConfig

你需要

  1. 使用所需的 Hikari 属性填充 HikariConfig 对象
  2. 使用作为参数传递给构造函数的 HikariConfig 对象初始化 HikariDataSource 对象。

我相信定义我自己的自定义配置类(@Configuration)来自己创建数据源并使用在单独文件中定义的数据源属性填充它(而不是传统的:application.properties)

以这种方式我可以定义我自己的使用 Hibernate 的 sessionFactory Bean 推荐:“LocalSessionFactoryBean”类并使用您的 Hikari 数据源 > 和其他基于 Hiberante-JPA 的属性填充它。

基于 Spring Boot 的 Hikari 数据源属性总结:-

spring.datasource.hikari.allow-pool-suspension=true
spring.datasource.hikari.auto-commit=false
spring.datasource.hikari.catalog=
spring.datasource.hikari.connection-init-sql=
spring.datasource.hikari.连接测试查询=
spring.datasource.hikari.connection-timeout=100
spring.datasource.hikari.data-source-class-name=
spring.datasource.hikari.data-source-jndi=
spring.datasource.hikari.driver -class-name=
spring.datasource.hikari.idle-timeout=50
spring.datasource.hikari.initialization-fail-fast=true
spring.datasource.hikari.isolate-internal-queries=true
spring.datasource.hikari.jdbc- url=
spring.datasource.hikari.leak-detection-threshold=
spring.datasource.hikari.login-timeout=60
spring.datasource.hikari.max-lifetime=
spring.datasource.hikari.maximum-pool-size=500
spring.datasource.hikari.minimum-idle=30
spring.datasource.hikari .password=
spring.datasource.hikari.pool-name=
spring.datasource.hikari.read-only=true
spring.datasource.hikari.register-mbeans=true
spring.datasource.hikari.transaction-isolation=
spring.datasource.hikari .username=
spring.datasource.hikari.validation-timeout=

于 2018-06-18T08:48:55.803 回答
3

下面的代码可用于静态数据源初始化。

public class MyDataSource {
    private static final String DB_USERNAME="spring.datasource.username";
    private static final String DB_PASSWORD="spring.datasource.password";
    private static final String DB_URL ="spring.datasource.url";
    private static final String DB_DRIVER_CLASS="spring.datasource.driver-class-name";

    private static Properties properties = null;
    private static HikariDataSource dataSource;

    static {
        try {
            properties = new Properties();
            properties.load(new FileInputStream("src/main/resources/application.properties"));

            dataSource = new HikariDataSource();
            dataSource.setDriverClassName(properties.getProperty(DB_DRIVER_CLASS));

            dataSource.setJdbcUrl(properties.getProperty(DB_URL));
            dataSource.setUsername(properties.getProperty(DB_USERNAME));
            dataSource.setPassword(properties.getProperty(DB_PASSWORD));

            dataSource.setMinimumIdle(100);
            dataSource.setMaximumPoolSize(2000);
            dataSource.setAutoCommit(false);
            dataSource.setLoginTimeout(3);

        } catch (IOException | SQLException e) {
            ((Throwable) e).printStackTrace();
        }
    }

    public static DataSource getDataSource(){
        return dataSource;
    }

    public static Connection getConnection() throws SQLException{
        return getDataSource().getConnection();
    }
}
于 2020-02-09T05:50:17.840 回答
3

现在用 HikcariCp 作为新版 Spring Boot 的默认连接池。可以直接如下图完成。

@Configuration
public class PurchaseOrderDbConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "com.sysco.purchaseorder.datasoure")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }

}

应用程序.yml

com:
  sysco:
    purchaseorder:
      datasoure:
        driverClassName: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://localhost:3306/purchaseorder
        username: root
        password: root123
        idleTimeout: 600000

如果您将打印空闲超时值的值

ApplicationContext context=SpringApplication.run(ApiBluePrint.class, args);
   HikariDataSource dataSource=(HikariDataSource) context.getBean(DataSource.class);
   System.out.println(dataSource.getIdleTimeout());

如果您没有定义任何自定义值,您将获得 600000 的值,其中默认值为 300000

于 2020-12-30T05:39:37.770 回答
2

随着后来的 spring-boot 版本切换到 Hikari 可以完全在配置中完成。我正在使用1.5.6.RELEASE,这种方法有效。

构建.gradle:

compile "com.zaxxer:HikariCP:2.7.3"

应用 YAML

spring:
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      idleTimeout: 60000
      minimumIdle: 2
      maximumPoolSize: 20
      connectionTimeout: 30000
      poolName: MyPoolName
      connectionTestQuery: SELECT 1

更改connectionTestQuery以适合您的基础数据库。就是这样,不需要代码。

于 2017-11-17T17:03:13.047 回答
1

我遇到了问题,问题是结尾处的空白spring.datasource.type = com.zaxxer.hikari.HikariDataSource

于 2020-01-20T12:56:47.760 回答
0

我正在与

HikariCP-4.0.3.jar
spring-boot-2.6.2.jar
spring-core-5.3.14.jar
spring-jdbc-5.3.14.jar
spring-web-5.3.14.jar
thymeleaf-3.0.14.RELEASE.jar

看起来 spring-boot 2.x 默认支持 HikariCP 开箱即用,这是个好消息。

我必须在我的 resources/application.properties 中为 2 个不同的 DS 进行以下配置

spring.sid1.datasource.jdbcUrl=jdbc:oracle:thin:@XXX:1521:SID1
spring.sid1.datasource.username=<user>
spring.sid1.datasource.password=<password>
spring.sid1.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.sid1.datasource.connectionTimeout=20000
spring.sid1.datasource.poolName=SID1Pool
spring.sid1.datasource.minimumIdle=5
spring.sid1.datasource.maximumPoolSize=10

spring.sid2.datasource.jdbcUrl=jdbc:oracle:thin:@XXX:1521:SID2
spring.sid2.datasource.username=<user2>
spring.sid2.datasource.password=<password2>
spring.sid2.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.sid2.datasource.connectionTimeout=20000
spring.sid2.datasource.poolName=SID2Pool
spring.sid2.datasource.minimumIdle=5
spring.sid2.datasource.maximumPoolSize=10

注意: spring.sid2.datasource.hikari.* 配置不是必需的,因为它是默认的新配置。

于 2022-02-02T15:18:18.340 回答