5 Advanced Spring Boot Database Configurations to Make Your Code Reviews Shine

Why basic tutorial database configuration is unsuitable for production

Typical tutorial settings only define spring.datasource.url, username and password. This allows the application to start but omits:

connection‑pool tuning

timeout control

transaction protection

slow‑SQL monitoring

read‑write separation

security hardening

Without these, a production deployment is fragile under burst traffic, database jitter, connection leaks, long‑running transactions, and primary/replica failover.

Advanced Config 1 – HikariCP connection‑pool deep tuning

Spring Boot uses HikariCP by default, but the out‑of‑the‑box values are not optimal for high‑concurrency workloads. The recommended application.yml is:

spring:
  datasource:
    url: jdbc:postgresql://prod-db:5432/mydb
    username: ${DB_USER}
    password: ${DB_PASS}
    hikari:
      maximum-pool-size: 30
      minimum-idle: 10
      idle-timeout: 600000
      connection-timeout: 30000
      max-lifetime: 1800000
      leak-detection-threshold: 20000

Key parameters:

maximum-pool-size – controls the maximum number of concurrent connections.

minimum-idle – guarantees a baseline number of idle connections.

max-lifetime – prevents the database from forcibly closing connections.

leak-detection-threshold – detects potential connection leaks.

Java configuration example ( DataSourceConfig.java):

//src/main/java/com/icoderoad/config/DataSourceConfig.java
package com.icoderoad.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {
    @Bean
    public DataSource dataSource() {
        HikariDataSource ds = new HikariDataSource();
        ds.setMaximumPoolSize(30);
        ds.setMinimumIdle(10);
        ds.setConnectionTimeout(30000);
        ds.setIdleTimeout(600000);
        ds.setMaxLifetime(1800000);
        return ds;
    }
}

Advanced Config 2 – Transaction timeout and isolation level control

A stalled SQL statement can exhaust the connection pool if transactions have no timeout. The article provides a global TransactionTemplate bean:

//src/main/java/com/icoderoad/config/TransactionConfig.java
package com.icoderoad.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

@Configuration
public class TransactionConfig {
    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager txManager) {
        TransactionTemplate template = new TransactionTemplate(txManager);
        // timeout in seconds
        template.setTimeout(30);
        // isolation level
        template.setIsolationLevel(TransactionTemplate.ISOLATION_READ_COMMITTED);
        return template;
    }
}

Advanced Config 3 – Read‑write splitting with a dynamic DataSource

Production environments typically route writes to a primary database and reads to replicas. A minimal dynamic routing implementation extends AbstractRoutingDataSource and obtains the current lookup key from a ThreadLocal holder:

//src/main/java/com/icoderoad/config/DynamicDataSource.java
package com.icoderoad.config;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceKey();
    }
}

When the context key is “read”, queries are directed to the replica, improving query performance, reducing primary load, and increasing overall system stability.

Advanced Config 4 – Slow‑SQL monitoring and log enhancement

Observability is essential in production. Enable detailed Hibernate SQL logging:

logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql: TRACE

Integrate the p6spy driver to capture full SQL statements and execution times. Maven dependency:

<dependency>
    <groupId>p6spy</groupId>
    <artifactId>p6spy</artifactId>
</dependency>

This setup makes slow queries visible during code review, providing a concrete metric for optimization.

Advanced Config 5 – Database security hardening (sensitive data masking)

Credentials should not be hard‑coded. Use environment variables:

spring:
  datasource:
    username: ${DB_USER}
    password: ${DB_PASS}

Typical Linux startup commands:

export DB_USER=produser
export DB_PASS=StrongPassword

Final takeaway – production‑grade database configuration checklist

Key items to verify during a code review:

Connection‑pool sizing and leak detection.

Transaction timeout and isolation settings.

Implementation of read‑write splitting.

Presence of slow‑SQL monitoring.

Secure handling of credentials.

These configurations move a Spring Boot application from “can connect” to a system that can sustain high‑traffic spikes and maintain stability.