- * 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
- *
+/*
+ * Copyright 2010-2023 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 tk.mybatis.spring.annotation;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanNameGenerator;
+import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
+import org.springframework.core.annotation.AliasFor;
import tk.mybatis.spring.mapper.MapperFactoryBean;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;
import java.lang.annotation.*;
/**
- * Use this annotation to register MyBatis mapper interfaces when using Java
- * Config. It performs when same work as {@link MapperScannerConfigurer} via
- * {@link tk.mybatis.spring.annotation.MapperScannerRegistrar}.
+ * Use this annotation to register MyBatis mapper interfaces when using Java Config. It performs when same work as
+ * {@link MapperScannerConfigurer} via {@link MapperScannerRegistrar}.
+ *
+ * Either {@link #basePackageClasses} or {@link #basePackages} (or its alias {@link #value}) may be specified to define
+ * specific packages to scan. Since 2.0.4, If specific packages are not defined, scanning will occur from the package of
+ * the class that declares this annotation.
+ *
+ * Configuration example:
+ *
*
- *
Configuration example:
*
* @Configuration
* @MapperScan("org.mybatis.spring.sample.mapper")
@@ -36,9 +43,7 @@
*
* @Bean
* public DataSource dataSource() {
- * return new EmbeddedDatabaseBuilder()
- * .addScript("schema.sql")
- * .build();
+ * return new EmbeddedDatabaseBuilder().addScript("schema.sql").build();
* }
*
* @Bean
@@ -57,86 +62,139 @@
*
* @author Michael Lanyon
* @author Eduardo Macarron
- *
- * @since 1.2.0
- * @see tk.mybatis.spring.annotation.MapperScannerRegistrar
+ * @author Qimiao Chen
+ * @see MapperScannerRegistrar
* @see MapperFactoryBean
+ * @since 1.2.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
-@Import(tk.mybatis.spring.annotation.MapperScannerRegistrar.class)
+@Import(MapperScannerRegistrar.class)
+@Repeatable(MapperScans.class)
public @interface MapperScan {
/**
- * Alias for the {@link #basePackages()} attribute. Allows for more concise
- * annotation declarations e.g.:
- * {@code @EnableMyBatisMapperScanner("org.my.pkg")} instead of {@code
- * @EnableMyBatisMapperScanner(basePackages= "org.my.pkg"})}.
+ * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation declarations e.g.:
+ * {@code @MapperScan("org.my.pkg")} instead of {@code @MapperScan(basePackages = "org.my.pkg"})}.
+ *
+ * @return base package names
*/
+ @AliasFor("basePackages")
String[] value() default {};
/**
- * Base packages to scan for MyBatis interfaces. Note that only interfaces
- * with at least one method will be registered; concrete classes will be
- * ignored.
+ * Base packages to scan for MyBatis interfaces. Note that only interfaces with at least one method will be
+ * registered; concrete classes will be ignored.
+ *
+ * @return base package names for scanning mapper interface
*/
+ @AliasFor("value")
String[] basePackages() default {};
/**
- * Type-safe alternative to {@link #basePackages()} for specifying the packages
- * to scan for annotated components. The package of each class specified will be scanned.
- *
Consider creating a special no-op marker class or interface in each package
- * that serves no purpose other than being referenced by this attribute.
+ * Type-safe alternative to {@link #basePackages()} for specifying the packages to scan for annotated components. The
+ * package of each class specified will be scanned.
+ *
+ * Consider creating a special no-op marker class or interface in each package that serves no purpose other than being
+ * referenced by this attribute.
+ *
+ * @return classes that indicate base package for scanning mapper interface
*/
Class[] basePackageClasses() default {};
/**
- * The {@link BeanNameGenerator} class to be used for naming detected components
- * within the Spring container.
+ * The {@link BeanNameGenerator} class to be used for naming detected components within the Spring container.
+ *
+ * @return the class of {@link BeanNameGenerator}
*/
Class nameGenerator() default BeanNameGenerator.class;
/**
* This property specifies the annotation that the scanner will search for.
*
- * The scanner will register all interfaces in the base package that also have
- * the specified annotation.
+ * The scanner will register all interfaces in the base package that also have the specified annotation.
*
* Note this can be combined with markerInterface.
+ *
+ * @return the annotation that the scanner will search for
*/
Class annotationClass() default Annotation.class;
/**
* This property specifies the parent that the scanner will search for.
*
- * The scanner will register all interfaces in the base package that also have
- * the specified interface class as a parent.
+ * The scanner will register all interfaces in the base package that also have the specified interface class as a
+ * parent.
*
* Note this can be combined with annotationClass.
+ *
+ * @return the parent that the scanner will search for
*/
Class markerInterface() default Class.class;
/**
- * Specifies which {@code SqlSessionTemplate} to use in the case that there is
- * more than one in the spring context. Usually this is only needed when you
- * have more than one datasource.
+ * Specifies which {@code SqlSessionTemplate} to use in the case that there is more than one in the spring context.
+ * Usually this is only needed when you have more than one datasource.
+ *
+ * @return the bean name of {@code SqlSessionTemplate}
*/
String sqlSessionTemplateRef() default "";
/**
- * Specifies which {@code SqlSessionFactory} to use in the case that there is
- * more than one in the spring context. Usually this is only needed when you
- * have more than one datasource.
+ * Specifies which {@code SqlSessionFactory} to use in the case that there is more than one in the spring context.
+ * Usually this is only needed when you have more than one datasource.
+ *
+ * @return the bean name of {@code SqlSessionFactory}
*/
String sqlSessionFactoryRef() default "";
/**
* Specifies a custom MapperFactoryBean to return a mybatis proxy as spring bean.
*
+ * @return the class of {@code MapperFactoryBean}
*/
Class factoryBean() default MapperFactoryBean.class;
+ /**
+ * Whether enable lazy initialization of mapper bean.
+ *
+ * Default is {@code false}.
+ *
+ *
+ * @return set {@code true} to enable lazy initialization
+ * @since 2.0.2
+ */
+ String lazyInitialization() default "";
+
+ /**
+ * Specifies the default scope of scanned mappers.
+ *
+ * Default is {@code ""} (equiv to singleton).
+ *
+ *
+ * @return the default scope
+ */
+ String defaultScope() default AbstractBeanDefinition.SCOPE_DEFAULT;
+
+ /**
+ * Specifies a flag that whether execute a property placeholder processing or not.
+ *
+ * The default is {@literal true}. This means that a property placeholder processing execute.
+ *
+ * @return a flag that whether execute a property placeholder processing or not
+ * @since 3.0.3
+ */
+ boolean processPropertyPlaceHolders() default true;
+
+ /**
+ * Specifies which types are not eligible for mapper scanning.
+ *
+ * @return array of customized mapper excludeFilter
+ * @since 3.0.3
+ */
+ ComponentScan.Filter[] excludeFilters() default {};
+
/**
* 通用 Mapper 的配置，一行一个配置
*
@@ -150,11 +208,4 @@
* @return
*/
String mapperHelperRef() default "";
-
- /**
- * Whether enable lazy initialization of mapper bean.
- * Default is {@code false}.
- * @return set {@code true} to enable lazy initialization
- */
- String lazyInitialization() default "";
-}
\ No newline at end of file
+}
diff --git a/spring/src/main/java/tk/mybatis/spring/annotation/MapperScannerRegistrar.java b/spring/src/main/java/tk/mybatis/spring/annotation/MapperScannerRegistrar.java
index a06bb6a55..6f6101a22 100644
--- a/spring/src/main/java/tk/mybatis/spring/annotation/MapperScannerRegistrar.java
+++ b/spring/src/main/java/tk/mybatis/spring/annotation/MapperScannerRegistrar.java
@@ -1,106 +1,165 @@
-/**
- * Copyright 2010-2016 the original author or authors.
- *
+/*
+ * Copyright 2010-2024 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 tk.mybatis.spring.annotation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
+import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.core.type.filter.AnnotationTypeFilter;
+import org.springframework.core.type.filter.AssignableTypeFilter;
+import org.springframework.core.type.filter.TypeFilter;
+import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import tk.mybatis.spring.mapper.ClassPathMapperScanner;
import tk.mybatis.spring.mapper.MapperFactoryBean;
+import tk.mybatis.spring.mapper.MapperScannerConfigurer;
import java.lang.annotation.Annotation;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
+/**
+ * A {@link ImportBeanDefinitionRegistrar} to allow annotation configuration of MyBatis mapper scanning. Using
+ * an @Enable annotation allows beans to be registered via @Component configuration, whereas implementing
+ * {@code BeanDefinitionRegistryPostProcessor} will work for XML configuration.
+ *
+ * @author Michael Lanyon
+ * @author Eduardo Macarron
+ * @author Putthiphong Boonphong
+ *
+ * @see MapperFactoryBean
+ * @see ClassPathMapperScanner
+ *
+ * @since 1.2.0
+ */
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
- public static final Logger LOGGER = LoggerFactory.getLogger(MapperScannerRegistrar.class);
- private ResourceLoader resourceLoader;
+ public static final Logger LOGGER = LoggerFactory.getLogger(MapperScannerRegistrar.class);
+
+ // Note: Do not move resourceLoader via cleanup
+ private ResourceLoader resourceLoader;
private Environment environment;
@Override
- public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+ public void setResourceLoader(ResourceLoader resourceLoader) {
+ this.resourceLoader = resourceLoader;
+ }
+
+ @Override
+ public void setEnvironment(Environment environment) {
+ this.environment = environment;
+ }
- AnnotationAttributes annoAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
- ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
- // this check is needed in Spring 3.1
- if (resourceLoader != null) {
- scanner.setResourceLoader(resourceLoader);
+ @Override
+ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+ var mapperScanAttrs = AnnotationAttributes
+ .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
+ if (mapperScanAttrs != null) {
+ registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
+ generateBaseBeanName(importingClassMetadata, 0));
}
+ }
+
+ void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
+ BeanDefinitionRegistry registry, String beanName) {
+
+ var builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
+ builder.addPropertyValue("processPropertyPlaceHolders", annoAttrs.getBoolean("processPropertyPlaceHolders"));
Class annotationClass = annoAttrs.getClass("annotationClass");
if (!Annotation.class.equals(annotationClass)) {
- scanner.setAnnotationClass(annotationClass);
+ builder.addPropertyValue("annotationClass", annotationClass);
}
Class markerInterface = annoAttrs.getClass("markerInterface");
if (!Class.class.equals(markerInterface)) {
- scanner.setMarkerInterface(markerInterface);
+ builder.addPropertyValue("markerInterface", markerInterface);
}
Class generatorClass = annoAttrs.getClass("nameGenerator");
if (!BeanNameGenerator.class.equals(generatorClass)) {
- scanner.setBeanNameGenerator(BeanUtils.instantiateClass(generatorClass));
+ builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
}
Class mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
- scanner.setMapperFactoryBean(BeanUtils.instantiateClass(mapperFactoryBeanClass));
+ builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
}
- scanner.setSqlSessionTemplateBeanName(annoAttrs.getString("sqlSessionTemplateRef"));
- scanner.setSqlSessionFactoryBeanName(annoAttrs.getString("sqlSessionFactoryRef"));
+ var sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
+ if (StringUtils.hasText(sqlSessionTemplateRef)) {
+ builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
+ }
- List basePackages = new ArrayList();
- for (String pkg : annoAttrs.getStringArray("value")) {
- if (StringUtils.hasText(pkg)) {
- basePackages.add(pkg);
- }
+ var sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
+ if (StringUtils.hasText(sqlSessionFactoryRef)) {
+ builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
}
- for (String pkg : annoAttrs.getStringArray("basePackages")) {
- if (StringUtils.hasText(pkg)) {
- basePackages.add(pkg);
- }
+
+ List basePackages = new ArrayList<>(Arrays.stream(annoAttrs.getStringArray("basePackages"))
+ .filter(StringUtils::hasText).collect(Collectors.toList()));
+
+ basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
+ .collect(Collectors.toList()));
+
+ if (basePackages.isEmpty()) {
+ basePackages.add(getDefaultBasePackage(annoMeta));
}
- for (Class clazz : annoAttrs.getClassArray("basePackageClasses")) {
- basePackages.add(ClassUtils.getPackageName(clazz));
+
+ var excludeFilterArray = annoAttrs.getAnnotationArray("excludeFilters");
+ if (excludeFilterArray.length > 0) {
+ List typeFilters = new ArrayList<>();
+ List> rawTypeFilters = new ArrayList<>();
+ for (AnnotationAttributes excludeFilters : excludeFilterArray) {
+ if (excludeFilters.getStringArray("pattern").length > 0) {
+ // in oder to apply placeholder resolver
+ rawTypeFilters.addAll(parseFiltersHasPatterns(excludeFilters));
+ } else {
+ typeFilters.addAll(typeFiltersFor(excludeFilters));
+ }
+ }
+ builder.addPropertyValue("excludeFilters", typeFilters);
+ builder.addPropertyValue("rawExcludeFilters", rawTypeFilters);
}
+
//优先级 mapperHelperRef > properties > springboot
String mapperHelperRef = annoAttrs.getString("mapperHelperRef");
String[] properties = annoAttrs.getStringArray("properties");
if (StringUtils.hasText(mapperHelperRef)) {
- scanner.setMapperHelperBeanName(mapperHelperRef);
+ builder.addPropertyValue("mapperHelperBeanName", mapperHelperRef);
} else if (properties != null && properties.length > 0) {
- scanner.setMapperProperties(properties);
+ builder.addPropertyValue("mapperProperties", properties);
} else {
try {
- scanner.setMapperProperties(this.environment);
+ builder.addPropertyValue("mapperProperties", this.environment);
} catch (Exception e) {
LOGGER.warn("只有 Spring Boot 环境中可以通过 Environment(配置文件,环境变量,运行参数等方式) 配置通用 Mapper，" +
"其他环境请通过 @MapperScan 注解中的 mapperHelperRef 或 properties 参数进行配置!" +
@@ -108,22 +167,119 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
}
}
- String lazyInitialization = annoAttrs.getString("lazyInitialization");
+ var lazyInitialization = annoAttrs.getString("lazyInitialization");
if (StringUtils.hasText(lazyInitialization)) {
- scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
+ builder.addPropertyValue("lazyInitialization", lazyInitialization);
}
- scanner.registerFilters();
- scanner.doScan(StringUtils.toStringArray(basePackages));
+ var defaultScope = annoAttrs.getString("defaultScope");
+ if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
+ builder.addPropertyValue("defaultScope", defaultScope);
+ }
+
+ builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
+
+ // for spring-native
+ builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
+
+ registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
+
}
- @Override
- public void setEnvironment(Environment environment) {
- this.environment = environment;
+ /**
+ * Parse excludeFilters which FilterType is REGEX or ASPECTJ
+ *
+ * @param filterAttributes
+ * AnnotationAttributes of excludeFilters
+ *
+ * @since 3.0.3
+ */
+ private List> parseFiltersHasPatterns(AnnotationAttributes filterAttributes) {
+
+ List> rawTypeFilters = new ArrayList<>();
+ FilterType filterType = filterAttributes.getEnum("type");
+ var expressionArray = filterAttributes.getStringArray("pattern");
+ for (String expression : expressionArray) {
+ switch (filterType) {
+ case REGEX:
+ case ASPECTJ:
+ Map typeFilter = new HashMap<>(16);
+ typeFilter.put("type", filterType.name().toLowerCase());
+ typeFilter.put("expression", expression);
+ rawTypeFilters.add(typeFilter);
+ break;
+ default:
+ throw new IllegalArgumentException("Cannot specify the 'pattern' attribute if use the " + filterType
+ + " FilterType in exclude filter of @MapperScan");
+ }
+ }
+ return rawTypeFilters;
}
- @Override
- public void setResourceLoader(ResourceLoader resourceLoader) {
- this.resourceLoader = resourceLoader;
+ /**
+ * Parse excludeFilters which FilterType is ANNOTATION ASSIGNABLE or CUSTOM
+ *
+ * @param filterAttributes
+ * AnnotationAttributes of excludeFilters
+ *
+ * @since 3.0.3
+ */
+ private List typeFiltersFor(AnnotationAttributes filterAttributes) {
+
+ List typeFilters = new ArrayList<>();
+ FilterType filterType = filterAttributes.getEnum("type");
+
+ for (Class filterClass : filterAttributes.getClassArray("value")) {
+ switch (filterType) {
+ case ANNOTATION:
+ Assert.isAssignable(Annotation.class, filterClass,
+ "Specified an unsupported type in 'ANNOTATION' exclude filter of @MapperScan");
+ @SuppressWarnings("unchecked")
+ var annoClass = (Class) filterClass;
+ typeFilters.add(new AnnotationTypeFilter(annoClass));
+ break;
+ case ASSIGNABLE_TYPE:
+ typeFilters.add(new AssignableTypeFilter(filterClass));
+ break;
+ case CUSTOM:
+ Assert.isAssignable(TypeFilter.class, filterClass,
+ "An error occured when processing a @ComponentScan " + "CUSTOM type filter: ");
+ typeFilters.add(BeanUtils.instantiateClass(filterClass, TypeFilter.class));
+ break;
+ default:
+ throw new IllegalArgumentException("Cannot specify the 'value' or 'classes' attribute if use the "
+ + filterType + " FilterType in exclude filter of @MapperScan");
+ }
+ }
+ return typeFilters;
}
+
+ private static String generateBaseBeanName(AnnotationMetadata importingClassMetadata, int index) {
+ return importingClassMetadata.getClassName() + "#" + MapperScannerRegistrar.class.getSimpleName() + "#" + index;
+ }
+
+ private static String getDefaultBasePackage(AnnotationMetadata importingClassMetadata) {
+ return ClassUtils.getPackageName(importingClassMetadata.getClassName());
+ }
+
+ /**
+ * A {@link MapperScannerRegistrar} for {@link MapperScans}.
+ *
+ * @since 2.0.0
+ */
+ static class RepeatingRegistrar extends MapperScannerRegistrar {
+ @Override
+ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+ var mapperScansAttrs = AnnotationAttributes
+ .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
+ if (mapperScansAttrs != null) {
+ var annotations = mapperScansAttrs.getAnnotationArray("value");
+ for (var i = 0; i < annotations.length; i++) {
+ registerBeanDefinitions(importingClassMetadata, annotations[i], registry,
+ generateBaseBeanName(importingClassMetadata, i));
+ }
+ }
+ }
+ }
+
}
diff --git a/spring/src/main/java/tk/mybatis/spring/annotation/MapperScans.java b/spring/src/main/java/tk/mybatis/spring/annotation/MapperScans.java
new file mode 100644
index 000000000..1528e3b9d
--- /dev/null
+++ b/spring/src/main/java/tk/mybatis/spring/annotation/MapperScans.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-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 tk.mybatis.spring.annotation;
+
+import org.springframework.context.annotation.Import;
+
+import java.lang.annotation.*;
+
+/**
+ * The Container annotation that aggregates several {@link tk.mybatis.spring.annotation.MapperScan} annotations.
+ *
+ * Can be used natively, declaring several nested {@link tk.mybatis.spring.annotation.MapperScan} annotations. Can also be used in conjunction with
+ * Java 8's support for repeatable annotations, where {@link tk.mybatis.spring.annotation.MapperScan} can simply be declared several times on the
+ * same method, implicitly generating this container annotation.
+ *
+ * @author Kazuki Shimizu
+ *
+ * @since 2.0.0
+ *
+ * @see tk.mybatis.spring.annotation.MapperScan
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@Import(MapperScannerRegistrar.RepeatingRegistrar.class)
+public @interface MapperScans {
+ MapperScan[] value();
+}
diff --git a/spring/src/main/java/tk/mybatis/spring/mapper/ClassPathMapperScanner.java b/spring/src/main/java/tk/mybatis/spring/mapper/ClassPathMapperScanner.java
index 11279ddb8..ff9e127d6 100644
--- a/spring/src/main/java/tk/mybatis/spring/mapper/ClassPathMapperScanner.java
+++ b/spring/src/main/java/tk/mybatis/spring/mapper/ClassPathMapperScanner.java
@@ -1,12 +1,12 @@
-/**
- * Copyright 2010-2016 the original author or authors.
- *
+/*
+ * Copyright 2010-2024 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.
@@ -15,20 +15,25 @@
*/
package tk.mybatis.spring.mapper;
+import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
-import org.mybatis.spring.mapper.MapperScannerConfigurer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.scope.ScopedProxyFactoryBean;
+import org.springframework.aop.scope.ScopedProxyUtils;
+import org.springframework.aot.AotDetector;
import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
+import org.springframework.core.NativeDetector;
import org.springframework.core.env.Environment;
-import org.springframework.core.type.classreading.MetadataReader;
-import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.AssignableTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
@@ -37,33 +42,37 @@
import tk.mybatis.mapper.entity.Config;
import tk.mybatis.mapper.mapperhelper.MapperHelper;
-import java.io.IOException;
import java.lang.annotation.Annotation;
-import java.util.Arrays;
-import java.util.Properties;
-import java.util.Set;
+import java.util.*;
/**
- * A {@link ClassPathBeanDefinitionScanner} that registers Mappers by
- * {@code basePackage}, {@code annotationClass}, or {@code markerInterface}. If
- * an {@code annotationClass} and/or {@code markerInterface} is specified, only
- * the specified types will be searched (searching for all interfaces will be
- * disabled).
+ * A {@link ClassPathBeanDefinitionScanner} that registers Mappers by {@code basePackage}, {@code annotationClass}, or
+ * {@code markerInterface}. If an {@code annotationClass} and/or {@code markerInterface} is specified, only the
+ * specified types will be searched (searching for all interfaces will be disabled).
*
- * This functionality was previously a private class of
- * {@link MapperScannerConfigurer}, but was broken out in version 1.2.0.
+ * This functionality was previously a private class of {@link MapperScannerConfigurer}, but was broken out in version
+ * 1.2.0.
*
* @author Hunter Presnall
* @author Eduardo Macarron
+ *
* @see MapperFactoryBean
+ *
* @since 1.2.0
*/
public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
+ private static final Logger LOGGER = LoggerFactory.getLogger(ClassPathMapperScanner.class);
+
+ // Copy of FactoryBean#OBJECT_TYPE_ATTRIBUTE which was added in Spring 5.2
+ static final String FACTORY_BEAN_OBJECT_TYPE = "factoryBeanObjectType";
+
private boolean addToConfig = true;
private boolean lazyInitialization;
+ private boolean printWarnLogIfNotFoundMappers = true;
+
private SqlSessionFactory sqlSessionFactory;
private SqlSessionTemplate sqlSessionTemplate;
@@ -80,19 +89,130 @@ public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
private String mapperHelperBeanName;
- private MapperFactoryBean mapperFactoryBean = new MapperFactoryBean