feat: add module mybatis-flex-spring-boot4-starter

mybatis-flex-spring-boot-starter/src/main/java/com/mybatisflex/spring/boot/FlexTransactionAutoConfiguration.java

@@ -39,7 +39,13 @@ import org.springframework.transaction.annotation.TransactionManagementConfigure
  *
  * @author michael
  */
-@ConditionalOnClass(Db.class)
+@ConditionalOnClass(
+    value = Db.class,
+    name = {
+        "org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration",
+        "org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration",
+    }
+)
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @ConditionalOnMissingBean(TransactionManager.class)
 @Configuration(proxyBeanMethods = false)

mybatis-flex-spring-boot-starter/src/main/java/com/mybatisflex/spring/boot/MultiDataSourceAutoConfiguration.java

@@ -54,7 +54,13 @@ import java.util.Optional;
 @ConditionalOnMybatisFlexDatasource()
 @Configuration(proxyBeanMethods = false)
 @EnableConfigurationProperties(MybatisFlexProperties.class)
-@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
+@ConditionalOnClass(
+    value = {SqlSessionFactory.class, SqlSessionFactoryBean.class},
+    name = {
+        "org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
+        "org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration",
+    }
+)
 @AutoConfigureBefore(value = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class}
     , name = {"com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure",
     "com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure"})

mybatis-flex-spring-boot-starter/src/main/java/com/mybatisflex/spring/boot/MybatisFlexAutoConfiguration.java

@@ -96,7 +96,12 @@ import java.util.stream.Stream;
  * @author 王帅
  */
 @Configuration(proxyBeanMethods = false)
-@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
+@ConditionalOnClass(
+    value = {SqlSessionFactory.class, SqlSessionFactoryBean.class},
+    name = {
+        "org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration",
+    }
+)
 @ConditionalOnSingleCandidate(DataSource.class)
 @EnableConfigurationProperties(MybatisFlexProperties.class)
 @AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})

mybatis-flex-spring-boot4-starter/pom.xml

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.mybatis-flex</groupId>
+        <artifactId>parent</artifactId>
+        <version>${revision}</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <name>mybatis-flex-spring-boot4-starter</name>
+    <artifactId>mybatis-flex-spring-boot4-starter</artifactId>
+    <packaging>jar</packaging>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.mybatis-flex</groupId>
+            <artifactId>mybatis-flex-spring-boot-starter</artifactId>
+            <version>${project.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.mybatis</groupId>
+                    <artifactId>mybatis-spring</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <version>${spring-boot4.version}</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure-processor</artifactId>
+            <version>${spring-boot4.version}</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+            <version>${spring-boot4.version}</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-jdbc</artifactId>
+            <version>${spring-boot4.version}</version>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.scripting</groupId>
+            <artifactId>mybatis-freemarker</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.scripting</groupId>
+            <artifactId>mybatis-velocity</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis.scripting</groupId>
+            <artifactId>mybatis-thymeleaf</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>4.0.3</version>
+            <scope>compile</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.2.18</version>
+            <scope>compile</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.chris2018998</groupId>
+            <artifactId>beecp</artifactId>
+            <version>3.4.1</version>
+            <scope>compile</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-dbcp2</artifactId>
+            <version>2.9.0</version>
+            <scope>compile</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>io.seata</groupId>
+            <artifactId>seata-rm-datasource</artifactId>
+            <version>1.7.0</version>
+            <scope>compile</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>com.mybatis-flex</groupId>
+            <artifactId>mybatis-flex-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis-spring</artifactId>
+            <version>3.0.5</version>
+        </dependency>
+    </dependencies>
+
+</project>

mybatis-flex-spring-boot4-starter/src/main/java/com/mybatisflex/spring/boot/v4/FlexTransactionAutoConfiguration.java

@@ -0,0 +1,74 @@
+/*
+ *  Copyright (c) 2022-2025, Mybatis-Flex (fuhai999@gmail.com).
+ *  <p>
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  <p>
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  <p>
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package com.mybatisflex.spring.boot.v4;
+
+import com.mybatisflex.core.row.Db;
+import com.mybatisflex.spring.FlexTransactionManager;
+import org.jspecify.annotations.NonNull;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.AutoConfigureOrder;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration;
+import org.springframework.boot.transaction.autoconfigure.TransactionAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+import org.springframework.core.Ordered;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionManager;
+import org.springframework.transaction.annotation.TransactionManagementConfigurer;
+
+/**
+ * MyBatis-Flex 事务自动配置。
+ *
+ * @author michael
+ */
+@ConditionalOnClass(
+    value = Db.class,
+    name = {
+        "org.springframework.boot.transaction.autoconfigure.TransactionAutoConfiguration",
+        "org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration",
+    }
+)
+@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+@ConditionalOnMissingBean(TransactionManager.class)
+@Configuration(proxyBeanMethods = false)
+@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
+@AutoConfigureAfter({MybatisFlexAutoConfiguration.class})
+@AutoConfigureBefore(value = {TransactionAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class})
+public class FlexTransactionAutoConfiguration implements TransactionManagementConfigurer {
+
+    /**
+     * 这里使用 final 修饰属性是因为：<br>
+     * <p>
+     * 1、调用 {@link #annotationDrivenTransactionManager} 方法会返回 TransactionManager 对象<br>
+     * 2、{@code @Bean} 注入又会返回 TransactionManager 对象<br>
+     * <p>
+     * 需要保证两个对象的一致性。
+     */
+    private final FlexTransactionManager flexTransactionManager = new FlexTransactionManager();
+
+    @NonNull
+    @Override
+    @Bean(name = "transactionManager")
+    public PlatformTransactionManager annotationDrivenTransactionManager() {
+        return flexTransactionManager;
+    }
+
+}

mybatis-flex-spring-boot4-starter/src/main/java/com/mybatisflex/spring/boot/v4/MultiDataSourceAutoConfiguration.java

@@ -0,0 +1,159 @@
+/*
+ *  Copyright (c) 2022-2024, Mybatis-Flex (fuhai999@gmail.com).
+ *  <p>
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  <p>
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  <p>
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+package com.mybatisflex.spring.boot.v4;
+
+import com.mybatisflex.core.datasource.DataSourceBuilder;
+import com.mybatisflex.core.datasource.DataSourceDecipher;
+import com.mybatisflex.core.datasource.DataSourceManager;
+import com.mybatisflex.core.datasource.FlexDataSource;
+import com.mybatisflex.core.dialect.DbType;
+import com.mybatisflex.core.dialect.DbTypeUtil;
+import com.mybatisflex.core.exception.FlexExceptions;
+import com.mybatisflex.core.util.MapUtil;
+import com.mybatisflex.spring.boot.ConditionalOnMybatisFlexDatasource;
+import com.mybatisflex.spring.boot.v4.MybatisFlexProperties.SeataConfig;
+import com.mybatisflex.spring.datasource.DataSourceAdvice;
+import io.seata.rm.datasource.DataSourceProxy;
+import io.seata.rm.datasource.xa.DataSourceProxyXA;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.mybatis.spring.SqlSessionFactoryBean;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration;
+import org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+
+import javax.sql.DataSource;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * MyBatis-Flex 多数据源的配置支持。
+ *
+ * @author michael
+ * @author 王帅
+ */
+@ConditionalOnMybatisFlexDatasource()
+@Configuration(proxyBeanMethods = false)
+@EnableConfigurationProperties(MybatisFlexProperties.class)
+@ConditionalOnClass(
+    value = {SqlSessionFactory.class, SqlSessionFactoryBean.class},
+    name = {
+        "org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration",
+        "org.springframework.boot.jdbc.autoconfigure.DataSourceTransactionManagerAutoConfiguration",
+    }
+)
+@AutoConfigureBefore(value = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class}
+    , name = {"com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure",
+    "com.alibaba.druid.spring.boot4.autoconfigure.DruidDataSourceAutoConfigure"})
+public class MultiDataSourceAutoConfiguration {
+
+    private final String master;
+
+    private final Map<String, Map<String, String>> dataSourceProperties;
+
+    private final SeataConfig seataConfig;
+
+    // 数据源解密器
+    protected final DataSourceDecipher dataSourceDecipher;
+
+
+    public MultiDataSourceAutoConfiguration(MybatisFlexProperties properties
+        , ObjectProvider<DataSourceDecipher> dataSourceDecipherProvider
+    ) {
+        dataSourceProperties = properties.getDatasource();
+        dataSourceDecipher = dataSourceDecipherProvider.getIfAvailable();
+        seataConfig = properties.getSeataConfig();
+        master = properties.getDefaultDatasourceKey();
+    }
+
+    @Bean
+    @ConditionalOnMissingBean
+    public DataSource dataSource() {
+
+        FlexDataSource flexDataSource = null;
+
+        if (dataSourceProperties != null && !dataSourceProperties.isEmpty()) {
+
+            if (dataSourceDecipher != null) {
+                DataSourceManager.setDecipher(dataSourceDecipher);
+            }
+
+            if (master != null) {
+                Map<String, String> map = dataSourceProperties.remove(master);
+                if (map != null) {
+                    // 这里创建master时，flexDataSource一定是null
+                    flexDataSource = addDataSource(MapUtil.entry(master, map), null);
+                } else {
+                    throw FlexExceptions.wrap("没有找到默认数据源 \"%s\" 对应的配置，请检查您的多数据源配置。", master);
+                }
+            }
+
+            for (Map.Entry<String, Map<String, String>> entry : dataSourceProperties.entrySet()) {
+                flexDataSource = addDataSource(entry, flexDataSource);
+            }
+        }
+
+        return flexDataSource;
+    }
+
+    private FlexDataSource addDataSource(Map.Entry<String, Map<String, String>> entry, FlexDataSource flexDataSource) {
+        DataSource dataSource = new DataSourceBuilder(entry.getValue()).build();
+        DataSourceManager.decryptDataSource(dataSource);
+
+        // 数据库类型
+        DbType dbType = null;
+        if (seataConfig != null && seataConfig.isEnable()) {
+            if (seataConfig.getSeataMode() == MybatisFlexProperties.SeataMode.XA) {
+                DataSourceProxyXA sourceProxyXa = new DataSourceProxyXA(dataSource);
+                dbType = DbType.findByName(sourceProxyXa.getDbType());
+                dataSource = sourceProxyXa;
+            } else {
+                DataSourceProxy dataSourceProxy = new DataSourceProxy(dataSource);
+                dbType = DbType.findByName(dataSourceProxy.getDbType());
+                dataSource = dataSourceProxy;
+            }
+        }
+
+        // 如果没有构建成功dbType，需要自解析
+        final DataSource lambdaInnerDataSource = dataSource;
+        dbType = Optional.ofNullable(dbType).orElseGet(() -> DbTypeUtil.getDbType(lambdaInnerDataSource));
+        if (flexDataSource == null) {
+            flexDataSource = new FlexDataSource(entry.getKey(), dataSource, dbType, false);
+        } else {
+            flexDataSource.addDataSource(entry.getKey(), dataSource, dbType, false);
+        }
+        return flexDataSource;
+    }
+
+
+    /**
+     * {@link com.mybatisflex.annotation.UseDataSource} 注解切换数据源切面。
+     */
+    @Bean
+    @ConditionalOnMissingBean
+    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+    public DataSourceAdvice dataSourceAdvice() {
+        return new DataSourceAdvice();
+    }
+
+}

mybatis-flex-spring-boot4-starter/src/main/java/com/mybatisflex/spring/boot/v4/MybatisFlexAutoConfiguration.java

@@ -0,0 +1,428 @@
+/*
+ *    Copyright 2015-2022 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package com.mybatisflex.spring.boot.v4;
+
+import com.mybatisflex.core.FlexGlobalConfig;
+import com.mybatisflex.core.datasource.DataSourceDecipher;
+import com.mybatisflex.core.datasource.DataSourceManager;
+import com.mybatisflex.core.logicdelete.LogicDeleteManager;
+import com.mybatisflex.core.logicdelete.LogicDeleteProcessor;
+import com.mybatisflex.core.mybatis.FlexConfiguration;
+import com.mybatisflex.core.table.DynamicSchemaProcessor;
+import com.mybatisflex.core.table.DynamicTableProcessor;
+import com.mybatisflex.core.table.TableManager;
+import com.mybatisflex.core.tenant.TenantFactory;
+import com.mybatisflex.core.tenant.TenantManager;
+import com.mybatisflex.spring.FlexSqlSessionFactoryBean;
+import com.mybatisflex.spring.boot.*;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.mapping.DatabaseIdProvider;
+import org.apache.ibatis.plugin.Interceptor;
+import org.apache.ibatis.scripting.LanguageDriver;
+import org.apache.ibatis.session.ExecutorType;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.apache.ibatis.type.TypeHandler;
+import org.mybatis.spring.SqlSessionFactoryBean;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.mybatis.spring.mapper.MapperFactoryBean;
+import org.mybatis.spring.mapper.MapperScannerConfigurer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.beans.factory.*;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.boot.autoconfigure.AutoConfigurationPackages;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+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.boot.jdbc.autoconfigure.DataSourceAutoConfiguration;
+import org.springframework.context.EnvironmentAware;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.env.Environment;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+import javax.sql.DataSource;
+import java.beans.PropertyDescriptor;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+
+/**
+ * Mybatis-Flex 的核心配置。
+ * <p>
+ * 参考 <a href="https://github.com/mybatis/spring-boot-starter/blob/master/mybatis-spring-boot-autoconfigure/src/main/java/org/mybatis/spring/boot/autoconfigure/MybatisAutoConfiguration.java">
+ * MybatisAutoConfiguration.java</a>
+ * <p>
+ * 为 Mybatis-Flex 开启自动配置功能，主要修改以下几个方面:
+ * <p>
+ * 1、替换配置为 mybatis-flex 的配置前缀<br>
+ * 2、修改 SqlSessionFactory 为 FlexSqlSessionFactoryBean<br>
+ * 3、修改 Configuration 为 FlexConfiguration<br>
+ *
+ * @author Eddú Meléndez
+ * @author Josh Long
+ * @author Kazuki Shimizu
+ * @author Eduardo Macarrón
+ * @author michael
+ * @author 王帅
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass(
+    value = {SqlSessionFactory.class, SqlSessionFactoryBean.class},
+    name = {
+        "org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration",
+    }
+)
+@ConditionalOnSingleCandidate(DataSource.class)
+@EnableConfigurationProperties(MybatisFlexProperties.class)
+@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
+public class MybatisFlexAutoConfiguration implements InitializingBean {
+
+    protected static final Logger logger = LoggerFactory.getLogger(MybatisFlexAutoConfiguration.class);
+
+    protected final MybatisFlexProperties properties;
+
+    protected final Interceptor[] interceptors;
+
+    protected final TypeHandler[] typeHandlers;
+
+    protected final LanguageDriver[] languageDrivers;
+
+    protected final ResourceLoader resourceLoader;
+
+    protected final DatabaseIdProvider databaseIdProvider;
+
+    protected final List<ConfigurationCustomizer> configurationCustomizers;
+
+    protected final List<SqlSessionFactoryBeanCustomizer> sqlSessionFactoryBeanCustomizers;
+
+    //数据源解密器
+    protected final DataSourceDecipher dataSourceDecipher;
+
+    //动态表名
+    protected final DynamicTableProcessor dynamicTableProcessor;
+
+    //动态 schema 处理器
+    protected final DynamicSchemaProcessor dynamicSchemaProcessor;
+
+    //多租户
+    protected final TenantFactory tenantFactory;
+
+    //自定义逻辑删除处理器
+    protected final LogicDeleteProcessor logicDeleteProcessor;
+
+    //初始化监听
+    protected final List<MyBatisFlexCustomizer> mybatisFlexCustomizers;
+
+
+    public MybatisFlexAutoConfiguration(MybatisFlexProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider,
+                                        ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider,
+                                        ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider,
+                                        ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
+                                        ObjectProvider<List<SqlSessionFactoryBeanCustomizer>> sqlSessionFactoryBeanCustomizers,
+                                        ObjectProvider<DataSourceDecipher> dataSourceDecipherProvider,
+                                        ObjectProvider<DynamicTableProcessor> dynamicTableProcessorProvider,
+                                        ObjectProvider<DynamicSchemaProcessor> dynamicSchemaProcessorProvider,
+                                        ObjectProvider<TenantFactory> tenantFactoryProvider,
+                                        ObjectProvider<LogicDeleteProcessor> logicDeleteProcessorProvider,
+                                        ObjectProvider<MyBatisFlexCustomizer> mybatisFlexCustomizerProviders
+    ) {
+        this.properties = properties;
+        this.interceptors = interceptorsProvider.getIfAvailable();
+        this.typeHandlers = typeHandlersProvider.getIfAvailable();
+        this.languageDrivers = languageDriversProvider.getIfAvailable();
+        this.resourceLoader = resourceLoader;
+        this.databaseIdProvider = databaseIdProvider.getIfAvailable();
+        this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
+        this.sqlSessionFactoryBeanCustomizers = sqlSessionFactoryBeanCustomizers.getIfAvailable();
+
+        //数据源解密器
+        this.dataSourceDecipher = dataSourceDecipherProvider.getIfAvailable();
+
+        //动态表名
+        this.dynamicTableProcessor = dynamicTableProcessorProvider.getIfAvailable();
+
+        //动态 schema 处理器
+        this.dynamicSchemaProcessor = dynamicSchemaProcessorProvider.getIfAvailable();
+
+        //多租户
+        this.tenantFactory = tenantFactoryProvider.getIfAvailable();
+
+        //逻辑删除处理器
+        this.logicDeleteProcessor = logicDeleteProcessorProvider.getIfAvailable();
+
+        //初始化监听器
+        this.mybatisFlexCustomizers = mybatisFlexCustomizerProviders.orderedStream().collect(Collectors.toList());
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        // 检测 MyBatis 原生配置文件是否存在
+        checkConfigFileExists();
+
+        // 添加 MyBatis-Flex 全局配置
+        if (properties.getGlobalConfig() != null) {
+            properties.getGlobalConfig().applyTo(FlexGlobalConfig.getDefaultConfig());
+        }
+
+        //数据源解密器
+        if (dataSourceDecipher != null) {
+            DataSourceManager.setDecipher(dataSourceDecipher);
+        }
+
+        // 动态表名配置
+        if (dynamicTableProcessor != null) {
+            TableManager.setDynamicTableProcessor(dynamicTableProcessor);
+        }
+
+        // 动态 schema 处理器配置
+        if (dynamicSchemaProcessor != null) {
+            TableManager.setDynamicSchemaProcessor(dynamicSchemaProcessor);
+        }
+
+        //多租户
+        if (tenantFactory != null) {
+            TenantManager.setTenantFactory(tenantFactory);
+        }
+
+        //逻辑删除处理器
+        if (logicDeleteProcessor != null) {
+            LogicDeleteManager.setProcessor(logicDeleteProcessor);
+        }
+
+        //初始化监听器
+        if (mybatisFlexCustomizers != null) {
+            mybatisFlexCustomizers.forEach(myBatisFlexCustomizer -> myBatisFlexCustomizer.customize(FlexGlobalConfig.getDefaultConfig()));
+        }
+    }
+
+    private void checkConfigFileExists() {
+        if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
+            Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
+            Assert.state(resource.exists(),
+                "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
+        }
+    }
+
+    @Bean
+    @ConditionalOnMissingBean
+    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
+
+        SqlSessionFactoryBean factory = new FlexSqlSessionFactoryBean();
+        factory.setDataSource(dataSource);
+        if (properties.getConfiguration() == null || properties.getConfiguration().getVfsImpl() == null) {
+            factory.setVfs(SpringBootVFS.class);
+        }
+        if (StringUtils.hasText(this.properties.getConfigLocation())) {
+            factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
+        }
+        applyConfiguration(factory);
+        if (this.properties.getConfigurationProperties() != null) {
+            factory.setConfigurationProperties(this.properties.getConfigurationProperties());
+        }
+        if (!ObjectUtils.isEmpty(this.interceptors)) {
+            factory.setPlugins(this.interceptors);
+        }
+        if (this.databaseIdProvider != null) {
+            factory.setDatabaseIdProvider(this.databaseIdProvider);
+        }
+        if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
+            factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
+        }
+        if (this.properties.getTypeAliasesSuperType() != null) {
+            factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
+        }
+        if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
+            factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
+        }
+        if (!ObjectUtils.isEmpty(this.typeHandlers)) {
+            factory.setTypeHandlers(this.typeHandlers);
+        }
+        Resource[] mapperLocations = this.properties.resolveMapperLocations();
+        if (!ObjectUtils.isEmpty(mapperLocations)) {
+            factory.setMapperLocations(mapperLocations);
+        }
+        Set<String> factoryPropertyNames = Stream
+            .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
+            .collect(Collectors.toSet());
+        Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
+        if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
+            // Need to mybatis-spring 2.0.2+
+            factory.setScriptingLanguageDrivers(this.languageDrivers);
+            if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
+                defaultLanguageDriver = this.languageDrivers[0].getClass();
+            }
+        }
+        if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
+            // Need to mybatis-spring 2.0.2+
+            factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
+        }
+        applySqlSessionFactoryBeanCustomizers(factory);
+        return factory.getObject();
+    }
+
+    protected void applyConfiguration(SqlSessionFactoryBean factory) {
+        MybatisFlexProperties.CoreConfiguration coreConfiguration = this.properties.getConfiguration();
+        FlexConfiguration configuration = null;
+        if (coreConfiguration != null || !StringUtils.hasText(this.properties.getConfigLocation())) {
+            configuration = new FlexConfiguration();
+        }
+        if (configuration != null && coreConfiguration != null) {
+            coreConfiguration.applyTo(configuration);
+        }
+        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
+            for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
+                customizer.customize(configuration);
+            }
+        }
+        factory.setConfiguration(configuration);
+    }
+
+    protected void applySqlSessionFactoryBeanCustomizers(SqlSessionFactoryBean factory) {
+        if (!CollectionUtils.isEmpty(this.sqlSessionFactoryBeanCustomizers)) {
+            for (SqlSessionFactoryBeanCustomizer customizer : this.sqlSessionFactoryBeanCustomizers) {
+                customizer.customize(factory);
+            }
+        }
+    }
+
+    @Bean
+    @ConditionalOnMissingBean
+    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
+        ExecutorType executorType = this.properties.getExecutorType();
+        if (executorType != null) {
+            return new SqlSessionTemplate(sqlSessionFactory, executorType);
+        } else {
+            return new SqlSessionTemplate(sqlSessionFactory);
+        }
+    }
+
+    /**
+     * This will just scan the same base package as Spring Boot does. If you want more power, you can explicitly use
+     * {@link org.mybatis.spring.annotation.MapperScan} but this will get typed mappers working correctly, out-of-the-box,
+     * similar to using Spring Data JPA repositories.
+     */
+    public static class AutoConfiguredMapperScannerRegistrar
+        implements BeanFactoryAware, EnvironmentAware, ImportBeanDefinitionRegistrar {
+
+        private BeanFactory beanFactory;
+        private Environment environment;
+
+        @Override
+        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+
+            if (!AutoConfigurationPackages.has(this.beanFactory)) {
+                logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
+                return;
+            }
+
+            logger.debug("Searching for mappers annotated with @Mapper");
+
+            List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
+            if (logger.isDebugEnabled()) {
+                packages.forEach(pkg -> logger.debug("Using auto-configuration base package '{}'", pkg));
+            }
+
+            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
+            builder.addPropertyValue("processPropertyPlaceHolders", true);
+            builder.addPropertyValue("annotationClass", Mapper.class);
+            builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
+            BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
+            Set<String> propertyNames = Stream.of(beanWrapper.getPropertyDescriptors()).map(PropertyDescriptor::getName)
+                .collect(Collectors.toSet());
+            if (propertyNames.contains("lazyInitialization")) {
+                // Need to mybatis-spring 2.0.2+
+                builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}");
+            }
+            if (propertyNames.contains("defaultScope")) {
+                // Need to mybatis-spring 2.0.6+
+                builder.addPropertyValue("defaultScope", "${mybatis.mapper-default-scope:}");
+            }
+
+            // for spring-native
+            boolean injectSqlSession = environment.getProperty("mybatis.inject-sql-session-on-mapper-scan", Boolean.class,
+                Boolean.TRUE);
+            if (injectSqlSession && this.beanFactory instanceof ListableBeanFactory) {
+                ListableBeanFactory listableBeanFactory = (ListableBeanFactory) this.beanFactory;
+                Optional<String> sqlSessionTemplateBeanName = Optional
+                    .ofNullable(getBeanNameForType(SqlSessionTemplate.class, listableBeanFactory));
+                Optional<String> sqlSessionFactoryBeanName = Optional
+                    .ofNullable(getBeanNameForType(SqlSessionFactory.class, listableBeanFactory));
+                if (sqlSessionTemplateBeanName.isPresent() || !sqlSessionFactoryBeanName.isPresent()) {
+                    builder.addPropertyValue("sqlSessionTemplateBeanName",
+                        sqlSessionTemplateBeanName.orElse("sqlSessionTemplate"));
+                } else {
+                    builder.addPropertyValue("sqlSessionFactoryBeanName", sqlSessionFactoryBeanName.get());
+                }
+            }
+            builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+
+            registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
+        }
+
+        @Override
+        public void setBeanFactory(BeanFactory beanFactory) {
+            this.beanFactory = beanFactory;
+        }
+
+        @Override
+        public void setEnvironment(Environment environment) {
+            this.environment = environment;
+        }
+
+        private String getBeanNameForType(Class<?> type, ListableBeanFactory factory) {
+            String[] beanNames = factory.getBeanNamesForType(type);
+            return beanNames.length > 0 ? beanNames[0] : null;
+        }
+
+    }
+
+    /**
+     * If mapper registering configuration or mapper scanning configuration not present, this configuration allow to scan
+     * mappers based on the same component-scanning path as Spring Boot itself.
+     */
+    @org.springframework.context.annotation.Configuration(proxyBeanMethods = false)
+    @Import(AutoConfiguredMapperScannerRegistrar.class)
+    @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
+    public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
+
+        @Override
+        public void afterPropertiesSet() {
+            logger.debug(
+                "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
+        }
+
+    }
+
+
+}

mybatis-flex-spring-boot4-starter/src/main/java/com/mybatisflex/spring/boot/v4/package-info.java

@@ -0,0 +1,20 @@
+/*
+ *  Copyright (c) 2022-2025, Mybatis-Flex (fuhai999@gmail.com).
+ *  <p>
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  <p>
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  <p>
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/**
+ * MyBatis-Flex Spring Boot 支持。
+ */
+package com.mybatisflex.spring.boot.v4;

mybatis-flex-spring-boot4-starter/src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -0,0 +1,91 @@
+{
+    "properties": [
+        {
+            "defaultValue": false,
+            "name": "mybatis-flex.lazy-initialization",
+            "description": "Set whether enable lazy initialization for mapper bean.",
+            "type": "java.lang.Boolean"
+        },
+        {
+            "defaultValue": "",
+            "name": "mybatis-flex.mapper-default-scope",
+            "description": "A default scope for mapper bean that scanned by auto-configure.",
+            "type": "java.lang.String"
+        },
+        {
+            "defaultValue": true,
+            "name": "mybatis-flex.inject-sql-session-on-mapper-scan",
+            "description": "Set whether inject a SqlSessionTemplate or SqlSessionFactory bean (If you want to back to the behavior of 2.2.1 or before, specify false). If you use together with spring-native, should be set true.",
+            "type": "java.lang.Boolean"
+        },
+        {
+            "name": "mybatis-flex.scripting-language-driver.velocity.userdirective",
+            "deprecation": {
+                "level": "error",
+                "reason": "The 'userdirective' is deprecated since Velocity 2.x. This property defined for keeping backward compatibility with older velocity version.",
+                "replacement": "mybatis-flex.scripting-language-driver.velocity.velocity-settings.runtime.custom_directives"
+            }
+        },
+        {
+            "defaultValue": true,
+            "name": "mybatis-flex.datasource",
+            "description": "多数据源配置",
+            "type": "java.util.Map<java.lang.String,com.mybatisflex.spring.boot.DataSourceProperty>"
+        },
+        {
+            "defaultValue": 0,
+            "name": "mybatis-flex.global-config.normal-value-of-logic-delete",
+            "description": "逻辑删除未删除值标记",
+            "type": "java.lang.Object"
+        },
+        {
+            "defaultValue": 1,
+            "name": "mybatis-flex.global-config.deleted-value-of-logic-delete",
+            "description": "逻辑删除已删除值标记",
+            "type": "java.lang.Object"
+        },
+        {
+            "defaultValue": 10,
+            "name": "mybatis-flex.global-config.default-page-size",
+            "description": "默认的分页查询时的每页数据量",
+            "type": "java.lang.Integer"
+        },
+        {
+            "defaultValue": 2,
+            "name": "mybatis-flex.global-config.default-relation-query-depth",
+            "description": "默认的 Relation 注解查询深度",
+            "type": "java.lang.Integer"
+        },
+        {
+            "name": "mybatis-flex.global-config.key-config.value",
+            "description": "使用的 ID 生成器名称 或者 Sequence 执行的 SQL 内容",
+            "type": "java.lang.String"
+        },
+        {
+            "defaultValue": true,
+            "name": "mybatis-flex.global-config.key-config.before",
+            "description": "是否在数据插入之前执行，只在非自增上配置有效",
+            "type": "java.lang.Boolean"
+        },
+        {
+            "name": "mybatis-flex.global-config.key-config.key-type",
+            "description": "ID 生成策略",
+            "type": "com.mybatisflex.annotation.KeyType"
+        },
+        {
+            "name": "mybatis-flex.global-config.logic-delete-column",
+            "description": "全局默认逻辑删除字段",
+            "type": "java.lang.String"
+        },
+        {
+            "name": "mybatis-flex.global-config.tenant-column",
+            "description": "全局默认多租户字段",
+            "type": "java.lang.String"
+        },
+        {
+            "name": "mybatis-flex.global-config.version-column",
+            "description": "全局默认逻辑乐观锁字段",
+            "type": "java.lang.String"
+        }
+    ]
+}

mybatis-flex-spring-boot4-starter/src/main/resources/META-INF/spring.factories

@@ -0,0 +1,9 @@
+# Depends On Database Initialization Detectors
+org.springframework.boot.sql.init.dependency.DependsOnDatabaseInitializationDetector=\
+com.mybatisflex.spring.boot.MybatisFlexDependsOnDatabaseInitializationDetector
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+  com.mybatisflex.spring.boot.v4.FlexTransactionAutoConfiguration,\
+  com.mybatisflex.spring.boot.v4.MultiDataSourceAutoConfiguration,\
+  com.mybatisflex.spring.boot.v4.MybatisFlexAutoConfiguration,\
+  com.mybatisflex.spring.boot.MybatisFlexAdminAutoConfiguration,\
+  com.mybatisflex.spring.boot.MybatisLanguageDriverAutoConfiguration

mybatis-flex-spring-boot4-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -0,0 +1,5 @@
+com.mybatisflex.spring.boot.v4.FlexTransactionAutoConfiguration
+com.mybatisflex.spring.boot.v4.MultiDataSourceAutoConfiguration
+com.mybatisflex.spring.boot.v4.MybatisFlexAutoConfiguration
+com.mybatisflex.spring.boot.MybatisFlexAdminAutoConfiguration
+com.mybatisflex.spring.boot.MybatisLanguageDriverAutoConfiguration

pom.xml

@@ -55,6 +55,7 @@
         <module>mybatis-flex-spring</module>
         <module>mybatis-flex-spring-boot-starter</module>
         <module>mybatis-flex-spring-boot3-starter</module>
+        <module>mybatis-flex-spring-boot4-starter</module>
         <module>mybatis-flex-solon-plugin</module>
         <module>mybatis-flex-loveqq-starter</module>
         <module>mybatis-flex-test</module>
@@ -86,6 +87,7 @@
         <spring.version>5.3.27</spring.version>
         <spring-batch.version>4.3.10</spring-batch.version>
         <spring-boot.version>2.7.11</spring-boot.version>
+        <spring-boot4.version>4.0.0-RC2</spring-boot4.version>
         <solon.version>3.0.1</solon.version>
         <loveqq.version>1.1.0-java8</loveqq.version>
 
@@ -331,7 +333,7 @@
                 <version>1.6</version>
                 <executions>
                     <execution>
-                        <phase>verify</phase>
+                        <phase>deploy</phase>
                         <goals>
                             <goal>sign</goal>
                         </goals>