MyBatis 整合SpringBoot 启动源码分析

最新推荐文章于 2024-04-01 22:43:15 发布
置顶 最新推荐文章于 2024-04-01 22:43:15 发布
阅读量288 收藏 1
点赞数 1
分类专栏： MyBatis Spring框架学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36927395/article/details/115077985
版权

MyBatis 整合SpringBoot 启动源码分析之Mapper的初始化

MyBatis使用教程
开启MyBatis 是通过@MapperScan

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
  String[] value() default {};
  String[] basePackages() default {};
  Class<?>[] basePackageClasses() default {};
  Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
  Class<? extends Annotation> annotationClass() default Annotation.class;
  Class<?> markerInterface() default Class.class;
  String sqlSessionTemplateRef() default "";
  String sqlSessionFactoryRef() default "";
	//这个是用于创建Mapper代理对象的工厂类
  Class<? extends MapperFactoryBean> factoryBean() default MapperFactoryBean.class;
  String lazyInitialization() default "";
  String defaultScope() default AbstractBeanDefinition.SCOPE_DEFAULT;

}

这里导入了一个MapperScannerRegistrar 用于扫描注册我们定义的Mapper接口

ImportBeanDefinitionRegistrar 的调用流程是怎样的呢
通过BeanDefinitionRegistryPostProcessor 中的postProcessBeanFactory方法引入Spring的Bean的读取过程
在这里插入图片描述

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {

  /**
   * {@inheritDoc}
   *
   * @deprecated Since 2.0.2, this method not used never.
   */
  @Override
  @Deprecated
  public void setResourceLoader(ResourceLoader resourceLoader) {
    // NOP
  }

  /**
   * 这里重写了ImportBeanDefinitionRegistrar 
   */
  @Override 
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    AnnotationAttributes 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) {
	//MapperScannerConfigurer MyBatis的配置类，读取了注解MapperScan 中设置的属性
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);

    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }

    Class<?> markerInterface = annoAttrs.getClass("markerInterface");
    if (!Class.class.equals(markerInterface)) {
      builder.addPropertyValue("markerInterface", markerInterface);
    }

    Class<? extends BeanNameGenerator> generatorClass = annoAttrs.getClass("nameGenerator");
    if (!BeanNameGenerator.class.equals(generatorClass)) {
      builder.addPropertyValue("nameGenerator", BeanUtils.instantiateClass(generatorClass));
    }

    Class<? extends MapperFactoryBean> mapperFactoryBeanClass = annoAttrs.getClass("factoryBean");
    if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {
      builder.addPropertyValue("mapperFactoryBeanClass", mapperFactoryBeanClass);
    }

    String sqlSessionTemplateRef = annoAttrs.getString("sqlSessionTemplateRef");
    if (StringUtils.hasText(sqlSessionTemplateRef)) {
      builder.addPropertyValue("sqlSessionTemplateBeanName", annoAttrs.getString("sqlSessionTemplateRef"));
    }

    String sqlSessionFactoryRef = annoAttrs.getString("sqlSessionFactoryRef");
    if (StringUtils.hasText(sqlSessionFactoryRef)) {
      builder.addPropertyValue("sqlSessionFactoryBeanName", annoAttrs.getString("sqlSessionFactoryRef"));
    }

    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));

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

    String lazyInitialization = annoAttrs.getString("lazyInitialization");
    if (StringUtils.hasText(lazyInitialization)) {
      builder.addPropertyValue("lazyInitialization", lazyInitialization);
    }

    String defaultScope = annoAttrs.getString("defaultScope");
    if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {
      builder.addPropertyValue("defaultScope", defaultScope);
    }

    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
	//将 MapperScannerConfigurer 对应的BeanDefinition注册进BeanFactory
	//这里其实还是扫描bean 定义的阶段
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }

  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 {
    /**
     * {@inheritDoc}
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      AnnotationAttributes mapperScansAttrs = AnnotationAttributes
          .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScans.class.getName()));
      if (mapperScansAttrs != null) {
        AnnotationAttributes[] annotations = mapperScansAttrs.getAnnotationArray("value");
        for (int i = 0; i < annotations.length; i++) {
          registerBeanDefinitions(importingClassMetadata, annotations[i], registry,
              generateBaseBeanName(importingClassMetadata, i));
        }
      }
    }
  }

}

这个类主要的作用是将MapperScannerConfigurer 对应的BeanDefinition注册进BeanFactory
MapperScannerConfigurer 实现了 BeanDefinitionRegistryPostProcessor
在postProcessBeanDefinitionRegistry 中开启了UserMapper的扫描
方法中的接口会在这里进行调用
在这里插入图片描述
和上面的ImportBeanDefinitionRegistrar 都是在PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors方法中嵌入Spring的BeanDefinition 周期。这个方法比较复杂，这里不做分析。只要知道其可以在这里回调MapperScannerConfigurer 中的扫描Mapper的接口即可

MapperScannerConfigurer.postProcessBeanDefinitionRegistry

 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }

    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    //注意这个是我们注解中的那个Class
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    if (StringUtils.hasText(defaultScope)) {
      scanner.setDefaultScope(defaultScope);
    }
    scanner.registerFilters();
    //开启扫描
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }

使用ClassPathMapperScanner 开启扫描

public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
 public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

    if (beanDefinitions.isEmpty()) {
      LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
          + "' package. Please check your configuration.");
    } else {
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    AbstractBeanDefinition definition;
    BeanDefinitionRegistry registry = getRegistry();
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (AbstractBeanDefinition) holder.getBeanDefinition();
      boolean scopedProxy = false;
      if (ScopedProxyFactoryBean.class.getName().equals(definition.getBeanClassName())) {
        definition = (AbstractBeanDefinition) Optional
            .ofNullable(((RootBeanDefinition) definition).getDecoratedDefinition())
            .map(BeanDefinitionHolder::getBeanDefinition).orElseThrow(() -> new IllegalStateException(
                "The target bean definition of scoped proxy bean not found. Root bean definition[" + holder + "]"));
        scopedProxy = true;
      }
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
          + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      //这里设置的mapperFactoryBeanClass 就是MapperFactoryBean 注解MapperScan 中的默认值
      definition.setBeanClass(this.mapperFactoryBeanClass);

      definition.getPropertyValues().add("addToConfig", this.addToConfig);

      // Attribute for MockitoPostProcessor
      // https://github.com/mybatis/spring-boot-starter/issues/475
      definition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, beanClassName);

      boolean explicitFactoryUsed = false;
      if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
        definition.getPropertyValues().add("sqlSessionFactory",
            new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionFactory != null) {
        definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
        explicitFactoryUsed = true;
      }

      if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
        if (explicitFactoryUsed) {
          LOGGER.warn(
              () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate",
            new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
        explicitFactoryUsed = true;
      } else if (this.sqlSessionTemplate != null) {
        if (explicitFactoryUsed) {
          LOGGER.warn(
              () -> "Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
        }
        definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);
        explicitFactoryUsed = true;
      }

      if (!explicitFactoryUsed) {
        LOGGER.debug(() -> "Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      }

      definition.setLazyInit(lazyInitialization);

      if (scopedProxy) {
        continue;
      }

      if (ConfigurableBeanFactory.SCOPE_SINGLETON.equals(definition.getScope()) && defaultScope != null) {
        definition.setScope(defaultScope);
      }

      if (!definition.isSingleton()) {
        BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(holder, registry, true);
        if (registry.containsBeanDefinition(proxyHolder.getBeanName())) {
          registry.removeBeanDefinition(proxyHolder.getBeanName());
        }
        registry.registerBeanDefinition(proxyHolder.getBeanName(), proxyHolder.getBeanDefinition());
      }

    }
  }

这里设置的mapperFactoryBeanClass 就是MapperFactoryBean 注解MapperScan 中的默认值
definition.setBeanClass(this.mapperFactoryBeanClass);
这个类就是用于初始化Bean 时的工厂类

MapperFactoryBean 通过getObject() 生成Mapper的代理对象

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

  private Class<T> mapperInterface;

  private boolean addToConfig = true;

  public MapperFactoryBean() {
    // intentionally empty
  }

  public MapperFactoryBean(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

//这个是Mapper接口注入MyBatis 配置的过程
  @Override
  protected void checkDaoConfig() {
    super.checkDaoConfig();

    notNull(this.mapperInterface, "Property 'mapperInterface' is required");

    Configuration configuration = getSqlSession().getConfiguration();
    if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
      try {
        configuration.addMapper(this.mapperInterface);
      } catch (Exception e) {
        logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
        throw new IllegalArgumentException(e);
      } finally {
        ErrorContext.instance().reset();
      }
    }
  }


  @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }


  @Override
  public Class<T> getObjectType() {
    return this.mapperInterface;
  }


  @Override
  public boolean isSingleton() {
    return true;
  }

  // ------------- mutators --------------

  public void setMapperInterface(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public void setAddToConfig(boolean addToConfig) {
    this.addToConfig = addToConfig;
  }

  public boolean isAddToConfig() {
    return addToConfig;
  }
}

最后根据调用时找到了
MapperRegistry.getMapper

 public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

Mapper的代理工厂

public class MapperProxyFactory<T> {

  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public Map<Method, MapperMethodInvoker> getMethodCache() {
    return methodCache;
  }

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

}

MapperProxy 实现了InvocationHandler 所以最终接口的调用是MapperProxy 里的invoke方法。
invoke 方法就封装了Mapper sql接口执行的过程。这里就不介绍了

回顾一下单独使用MyBatis的过程

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

//或者
DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(
BlogMapper.class
);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

根据SpringBoot的模块自动配置，所以我们很容易知道MyBatis的配置类是哪个
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration，
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
这两个类就定义了SqlSessionFactory 之类的配置，这里就不做介绍了

轻云K
关注
专栏目录
springboot整合Mybatis项目源码分析
一只小菜鸡
12-12 946
我们先来看看Mybatis的几个核心类SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession之间的关系；     大致流程是这个样子的，mybatis通过SqlSessionFactoryBuilder类的build方法和配置文件生成SqlSessionFactory对象，而SqlSession对象是通过SqlSessionFactor...
SpringBoot与Mybatis整合源码深度解析
qq_35634181的博客
05-28 2264
问题： SpringBoot中没有Mybatis的配置文件是如何完成对Mybatis的整合？ 在Mapper接口上不加@component或者是@repository也能将Mapper注入到Spring中，是如何实现的？ 所写的Mapper接口是如何关联到xml里面所写的sql语句的？ 如果对于上述三个问题的答案不是很清楚的话，可以往下面，本文将从源码的角度分析SpringBoot与Mybatis整合的源码，对于Spring和Mybatis的整...
SpringBoot+Mybatis整合完整源码
04-02
Spring Boot+Mybatis+Maven 整合项目，可供学习，教程地址https://blog.csdn.net/qq_33768099/article/details/79787215
SpringBoot源码分析（三）整合MyBatis
一些学习的记录，主要做个人知识总结整理
07-04 219
一、前言 ​ SpringBoot中是没有MyBatis的，可以通过在使用SpringBoot时如果我们要用MyBatis的话，需要相比普通引用MyBatis需要多做哪些工作？来反推出整合自动配置的原理 二、对比SpringBoot中使用MyBatis区别 1.pom方面 相比平时不一样的是，引用的是starter： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId&gt
springboot-01 简单整合mybatis
dongxiexie的博客
04-20 264
代码下载地址（含source源码）下载地址链接项目目录结构1 pom.xml文件添加mybatis依赖&lt;!-- mybatis整合springboot jar包 --&gt; &lt;dependency&gt;     &lt;groupId&gt;org.mybatis.spring.boot&lt;/groupId&gt;     &lt;artifactId&gt;mybati...
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
将Spring与Mybatis整合，可以充分利用两者的优点，构建出高效、灵活的Web应用。 1. **Spring整合Mybatis的基本步骤** - **引入依赖**: 在项目的pom.xml中添加Spring和Mybatis的相关依赖。 - **配置数据源**: ...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
将SpringBoot与Redis和MyBatis整合，可以构建出高效、可维护的后端服务。下面我们将详细探讨这些知识点。 **SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`...
Spring+SpringMVC+MyBatis+SpringBoot视频04
01-08
"125-springmvc-拦截器配置细节和源码分析.mp4"深入讲解了SpringMVC的拦截器机制，用于在请求处理前后的增强功能，如日志记录、权限验证等。"138-ssm-后台删除、添加、修改接口实现和postman测试.mp4"则涉及到实际的...
springboot整合Druid+mybatis
weixin_44096353的博客
08-07 1260
Druid Springboot集成Druid方案：一个是在POM中直接配置druid-spring-boot-starter，不用写任何代码；一个是配置druid，写几行代码，可以加入；在方案一基础上加入stat、wall后进行验证登录。 先献上github代码地址:https://github.com/yudiandemingzi/spring-boot-many-data-source 代码拉下来换下自己的mysql数据库地址,就可以直接运行。Druid的优点很明显,它的可视化界面可以监控Sql语句.
Mybatis整合springboot原理分析，MybatisAutoConfiguration，AutoConfiguredMapperScannerRegistrar
LeoHan
07-11 3039
本章需要参考之前的两篇博客： Mybatis整合spring原理分析，SqlSessionFactoryBean，MapperScan，MapperScannerRegistrar，MapperScannerConfigurer springboot自动装配原理，底层源码分析，条件注解实现机制 从之前springboot自动装配原理，在资源目录下应该存在META-INF/spring.factories文件，查看mybatis-spring-boot-autoconfigure模块，其下该文件内容如下：
JAVA版本不兼容
weixin_52360960的博客
08-09 566
和project structure中的版本号之后发现都是11，没有问题，但是在项目根目录下的终端运行。springboot后端报错。
2021-03-25
weixin_53358262的博客
03-25 287
spring-boot-starter的自动配置原理啥是spring-boot-starter自动配置原理 啥是spring-boot-starter 在我个人看来statrter十分像一个容器，是spring-boot的一个特性 ，更像是spring-boot提供的diy工具。 两者相似之处有很多，但starter为我们提供了额外的功能： 尽可能的自动配置Spring和第三方库。例如：无论是在spring中集成mybatis框架使用或是单纯的使用mybatis框架。我们都少不了需要配置数据源，事务管理
SpringBoot mybatis-starter解析
最新发布
Box_clf的博客
04-01 549
主要是协助使用注解来配置SQL语句的。前缀的properties的配置生效。
MyBatis整合SpringBoot-2.2.2 源码学习
parkerJ
02-21 409
舍得放。
初识Spring Boot（五）
许晨的博客
04-08 2807
自动配置原理1）、SpringBoot启动的时候加载主配置类，开启了自动配置功能 ==@EnableAutoConfiguration==@EnableAutoConfiguration 作用：-  利用EnableAutoConfigurationImportSelector给容器中导入一些组件- 导入那些组件可以查看selectImports()方法的内容；- List&lt;String&g...
springboot常见的条件依赖注解有
weixin_40648117的博客
07-16 969
这些是springboot特有的，常见的条件依赖注解有： @ConditionalOnBean，仅在当前上下文中存在某个bean时，才会实例化这个Bean。 @ConditionalOnClass，某个class位于类路径上，才会实例化这个Bean。 @ConditionalOnExpression，当表达式为true的时候，才会实例化这个Bean。 @ConditionalOnMissingBe...
Mybatis解析-自动注解MybatisAutoConfiguration详解
龚厂长的博客
10-18 4359
本文基于mybatis-spring 1.3.1和mybatis 3.4.4版本 该文件配置了MybatisAutoConfiguration作为mybatis的自动配置类。本文下面将详细分析该类。从注解上可以看出该类依赖于DataSource实例，mybatis使用的配置类是MybatisProperties，使用XML文件配置的大部分属性都可以通过MybatisProperties配置 sqlSessionFactory sqlSessionTemplate
报错记录_SpringBoot整合MyBatis
qq_62636613的博客
05-13 731
在使用SpringBoot整合MyBatis时出现的报错 最开始以为是Mapper接口、xml、Controller、Service其中一个写错了 最后看到了这个： Property 'configuration' and 'configLocation' can not specified with together 结果发现是因为配置yml时同时使用了config-location与configuration（具体原因尚不清楚） 具体如下： mybatis: config-loca..
Spring源码分析十：SpringBoot中Mybatis的自动化配置
猫吻鱼的博客
06-14 2795
文章目录一、前言二、 一、前言 本文是笔者阅读Spring源码的记录文章，由于本人技术水平有限，在文章中难免出现错误，如有发现，感谢各位指正。在阅读过程中也创建了一些衍生文章，衍生文章的意义是因为自己在看源码的过程中，部分知识点并不了解或者对某些知识点产生了兴趣，所以为了更好的阅读源码，所以开设了衍生篇的文章来更好的对这些知识点进行进一步的学习。 二、 ...
SpringBoot&MyBatis Plus后台系统与微信小程序整合项目源码
资源摘要信息: 本资源是一个完整的后台管理系统开发项目，结合了流行的...通过对SpringBoot、MyBatis Plus、Vue.js与Element UI以及微信小程序等技术的整合，开发人员能够构建出稳定高效、用户体验良好的企业级应用。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值