SpringBoot整合mybatis源码

最新推荐文章于 2024-04-07 15:40:16 发布
最新推荐文章于 2024-04-07 15:40:16 发布
阅读量955 收藏 21
点赞数 28
文章标签： spring boot mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53067547/article/details/135921527
版权

mybatis是我们开发中常用的ORM框架，在经过SpringBoot框架的整合后，mybatis的使用变得非常方便。那么mybatis-spring-boot-starter背后的整合原理是怎样的呢？本文通过源码分析，带领大家深入SpringBoot整合mybatis的过程。

本文基于SpringBoot2.3.5.RELEASE mybatis-spring-boot-starter2.1.4，如果有错，欢迎大家指出一起讨论。（熟悉mybatis源码食用更佳）

首先，SpringBoot整合mybatis是基于自动装配的，如果不熟悉自动装配，可以去看下我写的自动装配的文章SpringBoot自动装配原理之深入源码解析

首先，mybatis通过自动装配向spring容器内注入了一些Bean，这些Bean就是关键。

在这里插入图片描述
在这里插入图片描述
从上图可以看出向容器内注入MybatisAutoConfiguration这个类，从名字可以看出就是Mytbatis自动配置类。

@Configuration
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
public class MybatisAutoConfiguration implements InitializingBean {
    private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
    private final MybatisProperties 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;

    public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
        this.properties = properties;
        this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
        this.typeHandlers = (TypeHandler[])typeHandlersProvider.getIfAvailable();
        this.languageDrivers = (LanguageDriver[])languageDriversProvider.getIfAvailable();
        this.resourceLoader = resourceLoader;
        this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
        this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
    }

    public void afterPropertiesSet() {
        this.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)");
        }

    }

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setVfs(SpringBootVFS.class);
        if (StringUtils.hasText(this.properties.getConfigLocation())) {
            factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
        }

        this.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());
        }

        Set<String> factoryPropertyNames = (Set)Stream.of((new BeanWrapperImpl(SqlSessionFactoryBean.class)).getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
        Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
        if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
            factory.setScriptingLanguageDrivers(this.languageDrivers);
            if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
                defaultLanguageDriver = this.languageDrivers[0].getClass();
            }
        }

        if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
            factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
        }

        return factory.getObject();
    }

    private void applyConfiguration(SqlSessionFactoryBean factory) {
        org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
        if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
            configuration = new org.apache.ibatis.session.Configuration();
        }

        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
            Iterator var3 = this.configurationCustomizers.iterator();

            while(var3.hasNext()) {
                ConfigurationCustomizer customizer = (ConfigurationCustomizer)var3.next();
                customizer.customize(configuration);
            }
        }

        factory.setConfiguration(configuration);
    }

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        ExecutorType executorType = this.properties.getExecutorType();
        return executorType != null ? new SqlSessionTemplate(sqlSessionFactory, executorType) : new SqlSessionTemplate(sqlSessionFactory);
    }

    @Configuration
    @Import({MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})
    @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
    public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
        public MapperScannerRegistrarNotFoundConfiguration() {
        }

        public void afterPropertiesSet() {
            MybatisAutoConfiguration.logger.debug("Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
        }
    }

    public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar {
        private BeanFactory beanFactory;

        public AutoConfiguredMapperScannerRegistrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            if (!AutoConfigurationPackages.has(this.beanFactory)) {
                MybatisAutoConfiguration.logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
            } else {
                MybatisAutoConfiguration.logger.debug("Searching for mappers annotated with @Mapper");
                List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
                if (MybatisAutoConfiguration.logger.isDebugEnabled()) {
                    packages.forEach((pkg) -> {
                        MybatisAutoConfiguration.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 = (Set)Stream.of(beanWrapper.getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
                if (propertyNames.contains("lazyInitialization")) {
                    builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}");
                }

                if (propertyNames.contains("defaultScope")) {
                    builder.addPropertyValue("defaultScope", "${mybatis.mapper-default-scope:}");
                }

                registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
            }
        }

        public void setBeanFactory(BeanFactory beanFactory) {
            this.beanFactory = beanFactory;
        }
    }
}

mybatis整合SpringBoot的核心就是这个类。我们首先来看被@Bean注解修饰的sqlSessionFactory方法，这个方法是向Spring容器内注入了一个返回值类型为SqlSessionFactory的Bean方法，在spring的生命周期过程中会调用这个方法。这个方法内部利用spring的扩展机制FactoryBean将sqlSessionFactory注入到spring容器中。

@Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    	//new了一个FactoryBean对象
       SqlSessionFactoryBean factory = new SqlSessionFactoryBean(); 
        factory.setDataSource(dataSource);
        factory.setVfs(SpringBootVFS.class);
        if (StringUtils.hasText(this.properties.getConfigLocation())) {
            factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
        }

        this.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());
        }

        Set<String> factoryPropertyNames = (Set)Stream.of((new BeanWrapperImpl(SqlSessionFactoryBean.class)).getPropertyDescriptors()).map(FeatureDescriptor::getName).collect(Collectors.toSet());
        Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
        if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
            factory.setScriptingLanguageDrivers(this.languageDrivers);
            if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
                defaultLanguageDriver = this.languageDrivers[0].getClass();
            }
        }

        if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
            factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
        }

		//前面不重要，都是对配置文件的设置
		//调用getObject方法，返回SqlSessionFactory
        return factory.getObject();
    }

在这里插入图片描述

在这里插入图片描述

protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
        XMLConfigBuilder xmlConfigBuilder = null;
        Configuration targetConfiguration;
        Optional var10000;
        if (this.configuration != null) {
            targetConfiguration = this.configuration;
            if (targetConfiguration.getVariables() == null) {
                targetConfiguration.setVariables(this.configurationProperties);
            } else if (this.configurationProperties != null) {
                targetConfiguration.getVariables().putAll(this.configurationProperties);
            }
        } else if (this.configLocation != null) {
            xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), (String)null, this.configurationProperties);
            targetConfiguration = xmlConfigBuilder.getConfiguration();
        } else {
            LOGGER.debug(() -> {
                return "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration";
            });
            targetConfiguration = new Configuration();
            var10000 = Optional.ofNullable(this.configurationProperties);
            Objects.requireNonNull(targetConfiguration);
            var10000.ifPresent(targetConfiguration::setVariables);
        }

        var10000 = Optional.ofNullable(this.objectFactory);
        Objects.requireNonNull(targetConfiguration);
        var10000.ifPresent(targetConfiguration::setObjectFactory);
        var10000 = Optional.ofNullable(this.objectWrapperFactory);
        Objects.requireNonNull(targetConfiguration);
        var10000.ifPresent(targetConfiguration::setObjectWrapperFactory);
        var10000 = Optional.ofNullable(this.vfs);
        Objects.requireNonNull(targetConfiguration);
        var10000.ifPresent(targetConfiguration::setVfsImpl);
        Stream var24;
        if (StringUtils.hasLength(this.typeAliasesPackage)) {
            var24 = this.scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream().filter((clazz) -> {
                return !clazz.isAnonymousClass();
            }).filter((clazz) -> {
                return !clazz.isInterface();
            }).filter((clazz) -> {
                return !clazz.isMemberClass();
            });
            TypeAliasRegistry var10001 = targetConfiguration.getTypeAliasRegistry();
            Objects.requireNonNull(var10001);
            var24.forEach(var10001::registerAlias);
        }

        if (!ObjectUtils.isEmpty(this.typeAliases)) {
            Stream.of(this.typeAliases).forEach((typeAlias) -> {
                targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
                LOGGER.debug(() -> {
                    return "Registered type alias: '" + typeAlias + "'";
                });
            });
        }

        if (!ObjectUtils.isEmpty(this.plugins)) {
            Stream.of(this.plugins).forEach((plugin) -> {
                targetConfiguration.addInterceptor(plugin);
                LOGGER.debug(() -> {
                    return "Registered plugin: '" + plugin + "'";
                });
            });
        }

        if (StringUtils.hasLength(this.typeHandlersPackage)) {
            var24 = this.scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter((clazz) -> {
                return !clazz.isAnonymousClass();
            }).filter((clazz) -> {
                return !clazz.isInterface();
            }).filter((clazz) -> {
                return !Modifier.isAbstract(clazz.getModifiers());
            });
            TypeHandlerRegistry var25 = targetConfiguration.getTypeHandlerRegistry();
            Objects.requireNonNull(var25);
            var24.forEach(var25::register);
        }

        if (!ObjectUtils.isEmpty(this.typeHandlers)) {
            Stream.of(this.typeHandlers).forEach((typeHandler) -> {
                targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
                LOGGER.debug(() -> {
                    return "Registered type handler: '" + typeHandler + "'";
                });
            });
        }

        targetConfiguration.setDefaultEnumTypeHandler(this.defaultEnumTypeHandler);
        if (!ObjectUtils.isEmpty(this.scriptingLanguageDrivers)) {
            Stream.of(this.scriptingLanguageDrivers).forEach((languageDriver) -> {
                targetConfiguration.getLanguageRegistry().register(languageDriver);
                LOGGER.debug(() -> {
                    return "Registered scripting language driver: '" + languageDriver + "'";
                });
            });
        }

        var10000 = Optional.ofNullable(this.defaultScriptingLanguageDriver);
        Objects.requireNonNull(targetConfiguration);
        var10000.ifPresent(targetConfiguration::setDefaultScriptingLanguage);
        if (this.databaseIdProvider != null) {
            try {
                targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
            } catch (SQLException var23) {
                throw new NestedIOException("Failed getting a databaseId", var23);
            }
        }

        var10000 = Optional.ofNullable(this.cache);
        Objects.requireNonNull(targetConfiguration);
        var10000.ifPresent(targetConfiguration::addCache);
        if (xmlConfigBuilder != null) {
            try {
                xmlConfigBuilder.parse();
                LOGGER.debug(() -> {
                    return "Parsed configuration file: '" + this.configLocation + "'";
                });
            } catch (Exception var21) {
                throw new NestedIOException("Failed to parse config resource: " + this.configLocation, var21);
            } finally {
                ErrorContext.instance().reset();
            }
        }

        targetConfiguration.setEnvironment(new Environment(this.environment, (TransactionFactory)(this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory), this.dataSource));
        if (this.mapperLocations != null) {
            if (this.mapperLocations.length == 0) {
                LOGGER.warn(() -> {
                    return "Property 'mapperLocations' was specified but matching resources are not found.";
                });
            } else {
                Resource[] var3 = this.mapperLocations;
                int var4 = var3.length;

                for(int var5 = 0; var5 < var4; ++var5) {
                    Resource mapperLocation = var3[var5];
                    if (mapperLocation != null) {
                        try {
                            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(), targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
                            xmlMapperBuilder.parse();
                        } catch (Exception var19) {
                            throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", var19);
                        } finally {
                            ErrorContext.instance().reset();
                        }

                        LOGGER.debug(() -> {
                            return "Parsed mapper file: '" + mapperLocation + "'";
                        });
                    }
                }
            }
        } else {
            LOGGER.debug(() -> {
                return "Property 'mapperLocations' was not specified.";
            });
        }

		//下面mybatis代码
        return this.sqlSessionFactoryBuilder.build(targetConfiguration);

我们再来看第二个被@Bean注解修饰的sqlSessionTemplate方法。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
可以看到内部创建了sqlSession的代理类。代理逻辑如下。
在这里插入图片描述
可以看到非事务情况下，每调用一次就创建一次sqlSession，使用完就关闭（因为mybatis的DefaultSqlSession是线程不安全的）

我们再来看被@Import注解修斯的MapperScannerRegistrarNotFoundConfiguration

@Configuration
    @Import({MybatisAutoConfiguration.AutoConfiguredMapperScannerRegistrar.class})
    @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
    public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
        public MapperScannerRegistrarNotFoundConfiguration() {
        }

        public void afterPropertiesSet() {
            MybatisAutoConfiguration.logger.debug("Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
        }
    }

spring会解析Impost注解，我们来看下AutoConfiguredMapperScannerRegistrar这个类，这个类实现了ImportBeanDefinitionRegistrar接口，spring解析时会调用registerBeanDefinitions这个方法。
在这里插入图片描述
从图上可以看到该方法向spring容器注入了MapperScannerConfigurer这个类。
而这个类实现了BeanDefinitionRegistryPostProcessor接口。
在spring的生命周期过程中，会调用postProcessBeanDefinitionRegistry这个方法

在这里插入图片描述
创建了一个ClassPathMapperScanner对象，对启动类所在路径进行扫描

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
找到启动类下所有的@Mapper类。然后注入到容器中。

在这里插入图片描述

这个方法设置了一堆Mapper的beanDefinition属性，其中最重要的是将beanClass设置成
MapperFactoryBean
在这里插入图片描述

我们先来看下MapperFactoryBean的类图，发现它直接或间接实现了FactoryBean，InitializingBean接口。
在这里插入图片描述
在spring的生命周期过程中，会执行InitializingBean的afterPropertiesSet方法。
在这里插入图片描述
将mapper添加到configuration对象中。
在这里插入图片描述

在依赖注入mapper的时候，就会调用getObject方法。
在这里插入图片描述

在这里插入图片描述
下面就是mybatis的原生代码了。
在这里插入图片描述

总结

mybatis跟SpringBoot的整合就是利用spring注解跟spring的扩展点将mybatis一些重要的类注入到容器中从而完成整合。

码农dls
关注
  • 28
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
小白mybatis源码看这一遍就够了（5）| 与springboot整合以及@Mapper原理
菜 头笔记
04-23 969
mybatis源码分析系列： mybatis源码看这一遍就够了（1）| 前言 mybatis源码看这一遍就够了（2）| getMapper mybatis源码看一遍就够了（3）| Configuration及解析配置文件 mybatis源码看一遍就够了（4）| SqlSession.select调用分析 通过前面几章对mybatis的源码分析，相信大家对mybatis的流程原理也有了...
mybatis-spring-boot-starter初探 代码.zip
04-30
关于mybatis的spring boot可执行代码，对应的解说博客地址在：https://blog.csdn.net/heidashou/article/details/105812796，含有全过程截图和解说。
mybatis整合springboot源码分析
最新发布
tuoshu9814的博客
04-07 1303
mybatis整合springboot的流程找到自动配置类MybatisAutoConfiguration在自动配置类中创建了SqlSessionFactory, SqlSessionTemplate在MybatisAutoConfiguration有个内部配置类MapperScannerRegistrarNotFoundConfiguration，这个类核心注解@Import中AutoConfiguredMapperScannerRegistrar。
MyBatis-Spring-Boot-Starter源码解析
若鱼的专栏
04-17 799
我们以MyBatis-Spring-Boot-Starter:2.1.2为例，首先打开mybatis-spring-boot-autoconfigure:2.1.2，找到spring.factories： # Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.mybatis.spr...
Springboot整合MyBatis， yml配置，超详细从mybatis-spring-boot-starter根据源码进行配置，MybatisProperties类中的属性【源码版】）
CoderOu
06-30 2917
都知道springboot整合第三方框架，我们开发者使用的时候，大部分都是只需要在pom文件中导入相关的start依赖即可，springboot提供的start能够无缝的整合第三方框架，今天我们就来看一下mybatis-spring-boot-starter中的自动装配。 如果对springboot的启动器不清楚的，可以看一下我的 首先我们看一下mybatis-spring-boot-starter这个依赖他帮我们管理了哪些依赖 <?xml version="1.0" encoding="UTF-8"
Mybatis在Spring-boot中自动配置的底层源码分析
weixin_45307968的博客
07-09 133
前言：在Spring-boot结合Mybatis，我们只需要配置一些数据库连接的基本信息，写好Mapper和Dto就可以跑起来了。但是它是如何帮我们完成自动配置，并且执行我们的sql语句的呢？我们一起来看看吧。 spring-boot.version：2.3.7.RELEASE mybatis-spring-boot-starter2.1.4 MyBatisAutoConfiguration类是Mybatis的自动配置程序，在Mybatis启动时，开始自动配置。 第一步:启动核心MyBatisAuto.
springboot整个mybatis最基础，最详细附源码
weixin_48146191的博客
03-02 120
springboot+mybatis
springBoot整合mybatis源码
08-23
springBoot整合mybatis源码,直接可以在idea中运行，简单易学，上手快
SpringBoot+Mybatis整合完整源码
04-02
Spring Boot+Mybatis+Maven 整合项目，可供学习，教程地址https://blog.csdn.net/qq_33768099/article/details/79787215
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
一个完整而简单SSM项目，包含SQL脚本、代码与学习笔记。内容Spring如何整合SpringMVC与Mybatis以及整合原理的源码分析。
springboot整合mybatis
04-20
最简单的springboot整合mybatis的jar包，包含source源码包和class包，谢谢
springboot整合mybatis完整版代码示例
12-15
springboot整合mybatis示例 , 传统的spring 整合mybatis大家都知道光配置文件就很复杂, 繁琐, 有一个地方编写有问题, 整个项目就会跑不起来, 总而言之就是各自配置过于繁琐, 但是sprintboot就不一样了, 直接集成了好多spring的东西, 无需编写传统的spring配置文件, 就能很轻松方便的把项目跑起来, 提高了开发效率, 整个过程变得十分高效简洁, 使用起来那叫一个让人轻松愉悦, 哈哈哈
SpringBoot整合Mybatis示例源码
03-17
SpringBoot整合Mybatis示例源码，
springboot整合mybatis+shiro实现权限判定源码 下载
05-19
springboot整合mybatis以及shiro实现权限判定源码
SpringBoot整合Mybatis代码
07-14
该代码实现SpringBoot整合Mybatis的入门代码案例，适合初学者学习使用。
MyBatis与SpringBoot的集成篇（二）---剖析starter
chanalbert
05-05 303
源起 上篇我们讲到了MyBatis与SpringBoot的集成篇（一）—demo案例，在案例最后我们留下了一个疑问：mybatis-spring-boot-starter是何方神圣，功能是什么？为什么我们依赖了这个starter之后，开发变得简化了许多？ 初识mybatis-spring-boot-starter 该章节内容总结自官网 官网传送门 The MyBatis-Spring-...
SpringBoot整合MyBatis例子
ryelqy的博客
11-06 2517
1、pom.xml   &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mav
SpringBoot整合Mybatis！！附带源码！！
goodipip的博客
06-12 623
1. 需要注意properties中的配置信息；2. 需要注意在启动类中加@MapperScan注解，表示让项目启动自动取扫描mapper所在的路径；3. 在删除操作中，删除成功后要重定向（redirect）到列表页面；4. 需要注意在页面中使用thymeleaf语法。
Eclipse中实现SpringBoot与Mybatis整合（图文教程带源码）
BADAO_LIUMANG_QIZHI的博客
03-18 3491
场景 数据库中数据 实现效果 项目结构 前面参照 Eclipse中新建SpringBoot项目并输出HelloWorld https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/88359953 Eclipse中新建SpringBoot项目完成对json、pojo、map、list的请求 https://blo...
springboot整合mybatis 项目源码
12-23
通过以上步骤，我们可以实现Spring Boot整合MyBatis的项目源码。在项目中，可以使用注解和XML的方式来定义SQL语句和映射关系，并在Service层中调用Mapper接口的方法来实现数据库操作。这样就能够方便地实现持久层的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值