315 lines
15 KiB
Java
315 lines
15 KiB
Java
/*
|
|
* Copyright (c) 2011-2020, baomidou (jobob@qq.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>
|
|
* https://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.baomidou.mybatisplus.autoconfigure;
|
|
|
|
|
|
import com.baomidou.mybatisplus.core.MybatisConfiguration;
|
|
import com.baomidou.mybatisplus.core.config.GlobalConfig;
|
|
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
|
|
import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
|
|
import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
|
|
import com.baomidou.mybatisplus.core.injector.ISqlInjector;
|
|
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
|
|
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.BeanFactory;
|
|
import org.springframework.beans.factory.BeanFactoryAware;
|
|
import org.springframework.beans.factory.InitializingBean;
|
|
import org.springframework.beans.factory.ObjectProvider;
|
|
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.EnableAutoConfiguration;
|
|
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.autoconfigure.jdbc.DataSourceAutoConfiguration;
|
|
import org.springframework.boot.context.properties.EnableConfigurationProperties;
|
|
import org.springframework.context.ApplicationContext;
|
|
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.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.util.List;
|
|
import java.util.Optional;
|
|
import java.util.function.Consumer;
|
|
import java.util.stream.Stream;
|
|
|
|
/**
|
|
* {@link EnableAutoConfiguration Auto-Configuration} for Mybatis. Contributes a
|
|
* {@link SqlSessionFactory} and a {@link SqlSessionTemplate}.
|
|
* <p>
|
|
* If {@link org.mybatis.spring.annotation.MapperScan} is used, or a
|
|
* configuration file is specified as a property, those will be considered,
|
|
* otherwise this auto-configuration will attempt to register mappers based on
|
|
* the interface definitions in or under the root auto-configuration package.
|
|
* </p>
|
|
* <p> copy from {@link org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration}</p>
|
|
*
|
|
* @author Eddú Meléndez
|
|
* @author Josh Long
|
|
* @author Kazuki Shimizu
|
|
* @author Eduardo Macarrón
|
|
*/
|
|
@Configuration
|
|
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
|
|
@ConditionalOnSingleCandidate(DataSource.class)
|
|
@EnableConfigurationProperties(MybatisPlusProperties.class)
|
|
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
|
|
public class MybatisPlusAutoConfiguration implements InitializingBean {
|
|
|
|
private static final Logger logger = LoggerFactory.getLogger(MybatisPlusAutoConfiguration.class);
|
|
|
|
private final MybatisPlusProperties properties;
|
|
|
|
private final Interceptor[] interceptors;
|
|
|
|
private final TypeHandler[] typeHandlers;
|
|
|
|
private final LanguageDriver[] languageDrivers;
|
|
|
|
private final ResourceLoader resourceLoader;
|
|
|
|
private final DatabaseIdProvider databaseIdProvider;
|
|
|
|
private final List<ConfigurationCustomizer> configurationCustomizers;
|
|
|
|
private final List<MybatisPlusPropertiesCustomizer> mybatisPlusPropertiesCustomizers;
|
|
|
|
private final ApplicationContext applicationContext;
|
|
|
|
|
|
public MybatisPlusAutoConfiguration(MybatisPlusProperties properties,
|
|
ObjectProvider<Interceptor[]> interceptorsProvider,
|
|
ObjectProvider<TypeHandler[]> typeHandlersProvider,
|
|
ObjectProvider<LanguageDriver[]> languageDriversProvider,
|
|
ResourceLoader resourceLoader,
|
|
ObjectProvider<DatabaseIdProvider> databaseIdProvider,
|
|
ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
|
|
ObjectProvider<List<MybatisPlusPropertiesCustomizer>> mybatisPlusPropertiesCustomizerProvider,
|
|
ApplicationContext applicationContext) {
|
|
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.mybatisPlusPropertiesCustomizers = mybatisPlusPropertiesCustomizerProvider.getIfAvailable();
|
|
this.applicationContext = applicationContext;
|
|
}
|
|
|
|
@Override
|
|
public void afterPropertiesSet() {
|
|
if (!CollectionUtils.isEmpty(mybatisPlusPropertiesCustomizers)) {
|
|
mybatisPlusPropertiesCustomizers.forEach(i -> i.customize(properties));
|
|
}
|
|
checkConfigFileExists();
|
|
}
|
|
|
|
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)");
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
|
|
@Bean
|
|
@ConditionalOnMissingBean
|
|
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
|
|
// TODO 使用 MybatisSqlSessionFactoryBean 而不是 SqlSessionFactoryBean
|
|
MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
|
|
factory.setDataSource(dataSource);
|
|
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);
|
|
}
|
|
if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
|
|
factory.setMapperLocations(this.properties.resolveMapperLocations());
|
|
}
|
|
|
|
// TODO 对源码做了一定的修改(因为源码适配了老旧的mybatis版本,但我们不需要适配)
|
|
Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
|
|
if (!ObjectUtils.isEmpty(this.languageDrivers)) {
|
|
factory.setScriptingLanguageDrivers(this.languageDrivers);
|
|
}
|
|
Optional.ofNullable(defaultLanguageDriver).ifPresent(factory::setDefaultScriptingLanguageDriver);
|
|
|
|
// TODO 自定义枚举包
|
|
if (StringUtils.hasLength(this.properties.getTypeEnumsPackage())) {
|
|
factory.setTypeEnumsPackage(this.properties.getTypeEnumsPackage());
|
|
}
|
|
// TODO 此处必为非 NULL
|
|
GlobalConfig globalConfig = this.properties.getGlobalConfig();
|
|
// TODO 注入填充器
|
|
this.getBeanThen(MetaObjectHandler.class, globalConfig::setMetaObjectHandler);
|
|
// TODO 注入主键生成器
|
|
this.getBeanThen(IKeyGenerator.class, i -> globalConfig.getDbConfig().setKeyGenerator(i));
|
|
// TODO 注入sql注入器
|
|
this.getBeanThen(ISqlInjector.class, globalConfig::setSqlInjector);
|
|
// TODO 注入ID生成器
|
|
this.getBeanThen(IdentifierGenerator.class, globalConfig::setIdentifierGenerator);
|
|
// TODO 设置 GlobalConfig 到 MybatisSqlSessionFactoryBean
|
|
factory.setGlobalConfig(globalConfig);
|
|
return factory.getObject();
|
|
}
|
|
|
|
/**
|
|
* 检查spring容器里是否有对应的bean,有则进行消费
|
|
*
|
|
* @param clazz class
|
|
* @param consumer 消费
|
|
* @param <T> 泛型
|
|
*/
|
|
private <T> void getBeanThen(Class<T> clazz, Consumer<T> consumer) {
|
|
if (this.applicationContext.getBeanNamesForType(clazz, false, false).length > 0) {
|
|
consumer.accept(this.applicationContext.getBean(clazz));
|
|
}
|
|
}
|
|
|
|
// TODO 入参使用 MybatisSqlSessionFactoryBean
|
|
private void applyConfiguration(MybatisSqlSessionFactoryBean factory) {
|
|
// TODO 使用 MybatisConfiguration
|
|
MybatisConfiguration configuration = this.properties.getConfiguration();
|
|
if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
|
|
configuration = new MybatisConfiguration();
|
|
}
|
|
if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
|
|
for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
|
|
customizer.customize(configuration);
|
|
}
|
|
}
|
|
factory.setConfiguration(configuration);
|
|
}
|
|
|
|
@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, ImportBeanDefinitionRegistrar {
|
|
|
|
private BeanFactory beanFactory;
|
|
|
|
@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);
|
|
Stream.of(beanWrapper.getPropertyDescriptors())
|
|
// Need to mybatis-spring 2.0.2+
|
|
.filter(x -> x.getName().equals("lazyInitialization")).findAny()
|
|
.ifPresent(x -> builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}"));
|
|
registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
|
|
}
|
|
|
|
@Override
|
|
public void setBeanFactory(BeanFactory beanFactory) {
|
|
this.beanFactory = beanFactory;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
@Configuration
|
|
@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.");
|
|
}
|
|
}
|
|
}
|