MybatisPlusAutoConfiguration.java 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315
  1. /*
  2. * Copyright (c) 2011-2020, baomidou (jobob@qq.com).
  3. * <p>
  4. * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5. * use this file except in compliance with the License. You may obtain a copy of
  6. * the License at
  7. * <p>
  8. * https://www.apache.org/licenses/LICENSE-2.0
  9. * <p>
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13. * License for the specific language governing permissions and limitations under
  14. * the License.
  15. */
  16. package com.baomidou.mybatisplus.autoconfigure;
  17. import com.baomidou.mybatisplus.core.MybatisConfiguration;
  18. import com.baomidou.mybatisplus.core.config.GlobalConfig;
  19. import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
  20. import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
  21. import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
  22. import com.baomidou.mybatisplus.core.injector.ISqlInjector;
  23. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  24. import org.apache.ibatis.annotations.Mapper;
  25. import org.apache.ibatis.mapping.DatabaseIdProvider;
  26. import org.apache.ibatis.plugin.Interceptor;
  27. import org.apache.ibatis.scripting.LanguageDriver;
  28. import org.apache.ibatis.session.ExecutorType;
  29. import org.apache.ibatis.session.SqlSessionFactory;
  30. import org.apache.ibatis.type.TypeHandler;
  31. import org.mybatis.spring.SqlSessionFactoryBean;
  32. import org.mybatis.spring.SqlSessionTemplate;
  33. import org.mybatis.spring.mapper.MapperFactoryBean;
  34. import org.mybatis.spring.mapper.MapperScannerConfigurer;
  35. import org.slf4j.Logger;
  36. import org.slf4j.LoggerFactory;
  37. import org.springframework.beans.BeanWrapper;
  38. import org.springframework.beans.BeanWrapperImpl;
  39. import org.springframework.beans.factory.BeanFactory;
  40. import org.springframework.beans.factory.BeanFactoryAware;
  41. import org.springframework.beans.factory.InitializingBean;
  42. import org.springframework.beans.factory.ObjectProvider;
  43. import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  44. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  45. import org.springframework.boot.autoconfigure.AutoConfigurationPackages;
  46. import org.springframework.boot.autoconfigure.AutoConfigureAfter;
  47. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  48. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  49. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  50. import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
  51. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
  52. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  53. import org.springframework.context.ApplicationContext;
  54. import org.springframework.context.annotation.Bean;
  55. import org.springframework.context.annotation.Configuration;
  56. import org.springframework.context.annotation.Import;
  57. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
  58. import org.springframework.core.io.Resource;
  59. import org.springframework.core.io.ResourceLoader;
  60. import org.springframework.core.type.AnnotationMetadata;
  61. import org.springframework.util.Assert;
  62. import org.springframework.util.CollectionUtils;
  63. import org.springframework.util.ObjectUtils;
  64. import org.springframework.util.StringUtils;
  65. import javax.sql.DataSource;
  66. import java.util.List;
  67. import java.util.Optional;
  68. import java.util.function.Consumer;
  69. import java.util.stream.Stream;
  70. /**
  71. * {@link EnableAutoConfiguration Auto-Configuration} for Mybatis. Contributes a
  72. * {@link SqlSessionFactory} and a {@link SqlSessionTemplate}.
  73. * <p>
  74. * If {@link org.mybatis.spring.annotation.MapperScan} is used, or a
  75. * configuration file is specified as a property, those will be considered,
  76. * otherwise this auto-configuration will attempt to register mappers based on
  77. * the interface definitions in or under the root auto-configuration package.
  78. * </p>
  79. * <p> copy from {@link org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration}</p>
  80. *
  81. * @author Eddú Meléndez
  82. * @author Josh Long
  83. * @author Kazuki Shimizu
  84. * @author Eduardo Macarrón
  85. */
  86. @Configuration
  87. @ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
  88. @ConditionalOnSingleCandidate(DataSource.class)
  89. @EnableConfigurationProperties(MybatisPlusProperties.class)
  90. @AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
  91. public class MybatisPlusAutoConfiguration implements InitializingBean {
  92. private static final Logger logger = LoggerFactory.getLogger(MybatisPlusAutoConfiguration.class);
  93. private final MybatisPlusProperties properties;
  94. private final Interceptor[] interceptors;
  95. private final TypeHandler[] typeHandlers;
  96. private final LanguageDriver[] languageDrivers;
  97. private final ResourceLoader resourceLoader;
  98. private final DatabaseIdProvider databaseIdProvider;
  99. private final List<ConfigurationCustomizer> configurationCustomizers;
  100. private final List<MybatisPlusPropertiesCustomizer> mybatisPlusPropertiesCustomizers;
  101. private final ApplicationContext applicationContext;
  102. public MybatisPlusAutoConfiguration(MybatisPlusProperties properties,
  103. ObjectProvider<Interceptor[]> interceptorsProvider,
  104. ObjectProvider<TypeHandler[]> typeHandlersProvider,
  105. ObjectProvider<LanguageDriver[]> languageDriversProvider,
  106. ResourceLoader resourceLoader,
  107. ObjectProvider<DatabaseIdProvider> databaseIdProvider,
  108. ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
  109. ObjectProvider<List<MybatisPlusPropertiesCustomizer>> mybatisPlusPropertiesCustomizerProvider,
  110. ApplicationContext applicationContext) {
  111. this.properties = properties;
  112. this.interceptors = interceptorsProvider.getIfAvailable();
  113. this.typeHandlers = typeHandlersProvider.getIfAvailable();
  114. this.languageDrivers = languageDriversProvider.getIfAvailable();
  115. this.resourceLoader = resourceLoader;
  116. this.databaseIdProvider = databaseIdProvider.getIfAvailable();
  117. this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
  118. this.mybatisPlusPropertiesCustomizers = mybatisPlusPropertiesCustomizerProvider.getIfAvailable();
  119. this.applicationContext = applicationContext;
  120. }
  121. @Override
  122. public void afterPropertiesSet() {
  123. if (!CollectionUtils.isEmpty(mybatisPlusPropertiesCustomizers)) {
  124. mybatisPlusPropertiesCustomizers.forEach(i -> i.customize(properties));
  125. }
  126. checkConfigFileExists();
  127. }
  128. private void checkConfigFileExists() {
  129. if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
  130. Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
  131. Assert.state(resource.exists(),
  132. "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
  133. }
  134. }
  135. @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
  136. @Bean
  137. @ConditionalOnMissingBean
  138. public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
  139. // TODO 使用 MybatisSqlSessionFactoryBean 而不是 SqlSessionFactoryBean
  140. MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
  141. factory.setDataSource(dataSource);
  142. factory.setVfs(SpringBootVFS.class);
  143. if (StringUtils.hasText(this.properties.getConfigLocation())) {
  144. factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
  145. }
  146. applyConfiguration(factory);
  147. if (this.properties.getConfigurationProperties() != null) {
  148. factory.setConfigurationProperties(this.properties.getConfigurationProperties());
  149. }
  150. if (!ObjectUtils.isEmpty(this.interceptors)) {
  151. factory.setPlugins(this.interceptors);
  152. }
  153. if (this.databaseIdProvider != null) {
  154. factory.setDatabaseIdProvider(this.databaseIdProvider);
  155. }
  156. if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
  157. factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
  158. }
  159. if (this.properties.getTypeAliasesSuperType() != null) {
  160. factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
  161. }
  162. if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
  163. factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
  164. }
  165. if (!ObjectUtils.isEmpty(this.typeHandlers)) {
  166. factory.setTypeHandlers(this.typeHandlers);
  167. }
  168. Resource[] mapperLocations = this.properties.resolveMapperLocations();
  169. if (!ObjectUtils.isEmpty(mapperLocations)) {
  170. factory.setMapperLocations(mapperLocations);
  171. }
  172. // TODO 对源码做了一定的修改(因为源码适配了老旧的mybatis版本,但我们不需要适配)
  173. Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
  174. if (!ObjectUtils.isEmpty(this.languageDrivers)) {
  175. factory.setScriptingLanguageDrivers(this.languageDrivers);
  176. }
  177. Optional.ofNullable(defaultLanguageDriver).ifPresent(factory::setDefaultScriptingLanguageDriver);
  178. // TODO 自定义枚举包
  179. if (StringUtils.hasLength(this.properties.getTypeEnumsPackage())) {
  180. factory.setTypeEnumsPackage(this.properties.getTypeEnumsPackage());
  181. }
  182. // TODO 此处必为非 NULL
  183. GlobalConfig globalConfig = this.properties.getGlobalConfig();
  184. // TODO 注入填充器
  185. this.getBeanThen(MetaObjectHandler.class, globalConfig::setMetaObjectHandler);
  186. // TODO 注入主键生成器
  187. this.getBeanThen(IKeyGenerator.class, i -> globalConfig.getDbConfig().setKeyGenerator(i));
  188. // TODO 注入sql注入器
  189. this.getBeanThen(ISqlInjector.class, globalConfig::setSqlInjector);
  190. // TODO 注入ID生成器
  191. this.getBeanThen(IdentifierGenerator.class, globalConfig::setIdentifierGenerator);
  192. // TODO 设置 GlobalConfig 到 MybatisSqlSessionFactoryBean
  193. factory.setGlobalConfig(globalConfig);
  194. return factory.getObject();
  195. }
  196. /**
  197. * 检查spring容器里是否有对应的bean,有则进行消费
  198. *
  199. * @param clazz class
  200. * @param consumer 消费
  201. * @param <T> 泛型
  202. */
  203. private <T> void getBeanThen(Class<T> clazz, Consumer<T> consumer) {
  204. if (this.applicationContext.getBeanNamesForType(clazz, false, false).length > 0) {
  205. consumer.accept(this.applicationContext.getBean(clazz));
  206. }
  207. }
  208. // TODO 入参使用 MybatisSqlSessionFactoryBean
  209. private void applyConfiguration(MybatisSqlSessionFactoryBean factory) {
  210. // TODO 使用 MybatisConfiguration
  211. MybatisConfiguration configuration = this.properties.getConfiguration();
  212. if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
  213. configuration = new MybatisConfiguration();
  214. }
  215. if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
  216. for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
  217. customizer.customize(configuration);
  218. }
  219. }
  220. factory.setConfiguration(configuration);
  221. }
  222. @Bean
  223. @ConditionalOnMissingBean
  224. public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
  225. ExecutorType executorType = this.properties.getExecutorType();
  226. if (executorType != null) {
  227. return new SqlSessionTemplate(sqlSessionFactory, executorType);
  228. } else {
  229. return new SqlSessionTemplate(sqlSessionFactory);
  230. }
  231. }
  232. /**
  233. * This will just scan the same base package as Spring Boot does. If you want more power, you can explicitly use
  234. * {@link org.mybatis.spring.annotation.MapperScan} but this will get typed mappers working correctly, out-of-the-box,
  235. * similar to using Spring Data JPA repositories.
  236. */
  237. public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar {
  238. private BeanFactory beanFactory;
  239. @Override
  240. public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  241. if (!AutoConfigurationPackages.has(this.beanFactory)) {
  242. logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
  243. return;
  244. }
  245. logger.debug("Searching for mappers annotated with @Mapper");
  246. List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
  247. if (logger.isDebugEnabled()) {
  248. packages.forEach(pkg -> logger.debug("Using auto-configuration base package '{}'", pkg));
  249. }
  250. BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
  251. builder.addPropertyValue("processPropertyPlaceHolders", true);
  252. builder.addPropertyValue("annotationClass", Mapper.class);
  253. builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
  254. BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
  255. Stream.of(beanWrapper.getPropertyDescriptors())
  256. // Need to mybatis-spring 2.0.2+
  257. .filter(x -> x.getName().equals("lazyInitialization")).findAny()
  258. .ifPresent(x -> builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}"));
  259. registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
  260. }
  261. @Override
  262. public void setBeanFactory(BeanFactory beanFactory) {
  263. this.beanFactory = beanFactory;
  264. }
  265. }
  266. /**
  267. * If mapper registering configuration or mapper scanning configuration not present, this configuration allow to scan
  268. * mappers based on the same component-scanning path as Spring Boot itself.
  269. */
  270. @Configuration
  271. @Import(AutoConfiguredMapperScannerRegistrar.class)
  272. @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
  273. public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
  274. @Override
  275. public void afterPropertiesSet() {
  276. logger.debug(
  277. "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
  278. }
  279. }
  280. }