tessl/maven-org-springframework-boot--spring-boot-starter-jooq

Starter for using jOOQ to access SQL databases with JDBC, providing auto-configuration and Spring integration

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Spring Boot Starter jOOQ

Name: tessl/maven-org-springframework-boot--spring-boot-starter-jooq
Author: tessl

Spring Boot Starter for jOOQ provides seamless integration between Spring Boot and jOOQ (Java Object Oriented Querying), a type-safe SQL query builder. This starter automatically configures jOOQ components, integrates with Spring's transaction management, and provides exception translation to Spring's DataAccessException hierarchy.

Package Information

Package Name: spring-boot-starter-jooq
Package Type: Maven
Language: Java
Installation: Add dependency to your Maven or Gradle project

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jooq</artifactId>
    <version>3.5.3</version>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-jooq:3.5.3'

Core Imports

import org.jooq.DSLContext;
import org.jooq.Configuration;
import org.springframework.boot.autoconfigure.jooq.*;

For configuration properties:

import org.springframework.boot.context.properties.ConfigurationProperties;

Basic Usage

import org.jooq.DSLContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    
    @Autowired
    private DSLContext dsl;
    
    @Transactional
    public List<User> findActiveUsers() {
        return dsl.selectFrom(USER)
                  .where(USER.ACTIVE.eq(true))
                  .fetchInto(User.class);
    }
    
    @Transactional
    public void createUser(String name, String email) {
        dsl.insertInto(USER)
           .set(USER.NAME, name)
           .set(USER.EMAIL, email)
           .set(USER.ACTIVE, true)
           .execute();
    }
}

Architecture

Spring Boot Starter jOOQ is built around several key components:

Auto-Configuration: JooqAutoConfiguration automatically configures jOOQ components based on available beans and properties
Transaction Integration: Seamless integration with Spring's PlatformTransactionManager through SpringTransactionProvider
Exception Translation: Converts jOOQ/JDBC exceptions to Spring's DataAccessException hierarchy
SQL Dialect Detection: Automatically detects the appropriate SQL dialect from the configured DataSource
Configuration Customization: Supports customization through DefaultConfigurationCustomizer beans and external configuration files

Capabilities

Auto-Configuration

Core auto-configuration that sets up jOOQ beans automatically based on your Spring Boot application configuration. Provides the main DSLContext and Configuration beans, and ensures proper database initialization ordering.

@AutoConfiguration
@ConditionalOnClass(DSLContext.class)
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(JooqProperties.class)
public class JooqAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean(DSLContext.class)
    public DefaultDSLContext dslContext(org.jooq.Configuration configuration);
    
    @Bean
    @ConditionalOnMissingBean(org.jooq.Configuration.class)
    DefaultConfiguration jooqConfiguration(JooqProperties properties, 
                                          ConnectionProvider connectionProvider,
                                          DataSource dataSource, 
                                          ObjectProvider<TransactionProvider> transactionProvider,
                                          ObjectProvider<ExecuteListenerProvider> executeListenerProviders,
                                          ObjectProvider<DefaultConfigurationCustomizer> configurationCustomizers,
                                          ObjectProvider<Settings> settingsProvider);
}

Auto-Configuration

Configuration Properties

Configuration properties for customizing jOOQ behavior through Spring Boot's external configuration.

@ConfigurationProperties("spring.jooq")
public class JooqProperties {
    private SQLDialect sqlDialect;
    private Resource config;
    
    public SQLDialect getSqlDialect();
    public void setSqlDialect(SQLDialect sqlDialect);
    public Resource getConfig();
    public void setConfig(Resource config);
    public SQLDialect determineSqlDialect(DataSource dataSource);
}

Configuration

Transaction Integration

Integration with Spring's transaction management system, allowing jOOQ operations to participate in Spring-managed transactions.

public class SpringTransactionProvider implements TransactionProvider {
    public SpringTransactionProvider(PlatformTransactionManager transactionManager);
    public void begin(TransactionContext context);
    public void commit(TransactionContext ctx);
    public void rollback(TransactionContext ctx);
}

Transaction Integration

Exception Translation

Automatic translation of jOOQ and JDBC exceptions to Spring's DataAccessException hierarchy for consistent error handling.

public interface ExceptionTranslatorExecuteListener extends ExecuteListener {
    ExceptionTranslatorExecuteListener DEFAULT = new DefaultExceptionTranslatorExecuteListener();
    
    static ExceptionTranslatorExecuteListener of(
        Function<ExecuteContext, SQLExceptionTranslator> translatorFactory);
}

Exception Handling

Testing Integration

Testing support for jOOQ-based components with slice testing capabilities that focus only on jOOQ components while providing embedded database support.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@BootstrapWith(JooqTestContextBootstrapper.class)
@ExtendWith(SpringExtension.class)
@Transactional
@AutoConfigureJooq
public @interface JooqTest {
    String[] properties() default {};
    boolean useDefaultFilters() default true;
    Filter[] includeFilters() default {};  
    Filter[] excludeFilters() default {};
    Class<?>[] excludeAutoConfiguration() default {};
}

Testing Integration