or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

auto-configuration.mdconfiguration-properties.mdcustomization.mdindex.mdtesting-support.md
tile.json

tessl/maven-org-mybatis-spring-boot--mybatis-spring-boot-starter

Spring Boot Starter for MyBatis integration providing auto-configuration and dependency management

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.mybatis.spring.boot/mybatis-spring-boot-starter@3.0.x

To install, run

npx @tessl/cli install tessl/maven-org-mybatis-spring-boot--mybatis-spring-boot-starter@3.0.0

index.mddocs/

MyBatis Spring Boot Starter

A Spring Boot Starter that provides seamless integration between MyBatis ORM and Spring Boot applications through automatic configuration and dependency management. This starter eliminates boilerplate configuration while providing extensive customization options for database access layers.

Package Information

  • Package Name: mybatis-spring-boot-starter
  • Package Type: maven
  • Language: Java
  • Installation: Add to pom.xml dependencies:
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.4</version>
</dependency>

Core Imports

import org.mybatis.spring.boot.autoconfigure.MybatisProperties;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.mybatis.spring.boot.autoconfigure.SqlSessionFactoryBeanCustomizer;

For testing support:

import org.mybatis.spring.boot.test.autoconfigure.MybatisTest;
import org.mybatis.spring.boot.test.autoconfigure.AutoConfigureMybatis;

Basic Usage

// 1. Add starter dependency to pom.xml
// 2. Configure database connection in application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=user
spring.datasource.password=password

// Configure MyBatis settings
mybatis.mapper-locations=classpath:mappers/*.xml
mybatis.type-aliases-package=com.example.model
mybatis.configuration.map-underscore-to-camel-case=true

// 3. Create mapper interface with @Mapper annotation
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);
    
    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insert(User user);
}

// 4. Use in service classes (auto-injected by Spring)
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long id) {
        return userMapper.findById(id);
    }
}

Architecture

MyBatis Spring Boot Starter is built around several key components:

  • Auto-Configuration: MybatisAutoConfiguration automatically configures SqlSessionFactory and SqlSessionTemplate beans based on application properties
  • Properties Binding: MybatisProperties maps all mybatis.* configuration properties to MyBatis settings
  • Mapper Scanning: Automatic detection and registration of interfaces annotated with @Mapper
  • Customization Points: Interfaces like ConfigurationCustomizer and SqlSessionFactoryBeanCustomizer for advanced customization
  • Testing Support: @MybatisTest annotation for focused integration testing of MyBatis components
  • Language Driver Support: Auto-configuration for FreeMarker, Velocity, and Thymeleaf scripting engines

Capabilities

Configuration Properties

Core configuration system that maps Spring Boot properties to MyBatis settings, providing type-safe configuration for all MyBatis features including caching, lazy loading, type handling, and database-specific settings.

import org.apache.ibatis.scripting.LanguageDriver;
import org.apache.ibatis.session.ExecutorType;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.core.io.Resource;
import java.util.Properties;

@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties {
    public static final String MYBATIS_PREFIX = "mybatis";
    
    private String configLocation;
    private String[] mapperLocations;
    private String typeAliasesPackage;
    private Class<?> typeAliasesSuperType;
    private String typeHandlersPackage;
    private boolean checkConfigLocation;
    private ExecutorType executorType;
    private Class<? extends LanguageDriver> defaultScriptingLanguageDriver;
    private Properties configurationProperties;
    private CoreConfiguration configuration;
    
    // All getter and setter methods
    public Resource[] resolveMapperLocations();
}

Configuration Properties

Customization Interfaces

Functional interfaces that provide extension points for customizing MyBatis configuration and SqlSessionFactory creation during the auto-configuration process.

@FunctionalInterface
public interface ConfigurationCustomizer {
    void customize(Configuration configuration);
}

@FunctionalInterface
public interface SqlSessionFactoryBeanCustomizer {
    void customize(SqlSessionFactoryBean factoryBean);
}

Customization

Auto-Configuration Classes

Spring Boot auto-configuration classes that automatically set up MyBatis components based on classpath detection and configuration properties, including support for multiple scripting language drivers.

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
public class MybatisAutoConfiguration implements InitializingBean {
    
    public MybatisAutoConfiguration(
        MybatisProperties properties,
        ObjectProvider<Interceptor[]> interceptorsProvider,
        ObjectProvider<TypeHandler[]> typeHandlersProvider,
        ObjectProvider<LanguageDriver[]> languageDriversProvider,
        ResourceLoader resourceLoader,
        ObjectProvider<DatabaseIdProvider> databaseIdProvider,
        ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
        ObjectProvider<List<SqlSessionFactoryBeanCustomizer>> sqlSessionFactoryBeanCustomizers
    );
    
    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception;
    
    @Bean
    @ConditionalOnMissingBean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory);
    
    @Override
    public void afterPropertiesSet();
}

Auto-Configuration

Testing Support

Testing annotations and configuration classes designed for slice testing, allowing focused testing of MyBatis components without loading the full Spring application context.

import org.springframework.boot.test.autoconfigure.OverrideAutoConfiguration;
import org.springframework.boot.test.autoconfigure.filter.TypeExcludeFilters;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.core.annotation.AliasFor;
import org.springframework.test.context.BootstrapWith;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.Transactional;
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@BootstrapWith(MybatisTestContextBootstrapper.class)
@ExtendWith(SpringExtension.class)
@OverrideAutoConfiguration(enabled = false)
@TypeExcludeFilters(MybatisTypeExcludeFilter.class)
@Transactional
@AutoConfigureCache
@AutoConfigureMybatis
@AutoConfigureTestDatabase
@ImportAutoConfiguration
public @interface MybatisTest {
    String[] properties() default {};
    boolean useDefaultFilters() default true;
    Filter[] includeFilters() default {};
    Filter[] excludeFilters() default {};
    @AliasFor(annotation = ImportAutoConfiguration.class, attribute = "exclude")
    Class<?>[] excludeAutoConfiguration() default {};
}

Testing Support