Mybatis源码分析5--与Spring集成

最新推荐文章于 2024-12-12 18:17:55 发布
原创 最新推荐文章于 2024-12-12 18:17:55 发布
· 486 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #intellij-idea

Mybatis与Spring集成时的配置

<!-- 配置sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--配置扫描器，扫描mapper接口 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<property name="basePackage" value="com.gupaoedu.crud.dao"/>
</bean>
<!-- 配置sqlSession -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
	<constructor-arg  ref="sqlSessionFactory"></constructor-arg>
	<constructor-arg  value="BATCH"></constructor-arg>
</bean>

下面看一下这三个配置具体做了什么

1、SqlSessionFactoryBean

SqlSessionFactoryBean的继承关系

SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent>

SqlSessionFactoryBean实现了FactoryBean接口，会重写getObject()方法,返回SqlSessionFactory

//org.mybatis.spring.SqlSessionFactoryBean#getObject
public SqlSessionFactory getObject() throws Exception {
  //如果sqlSessionFactory没有创建，则创建
  if (this.sqlSessionFactory == null) {
    //创建sqlSessionFactory
    afterPropertiesSet();
  }
  //返回sqlSessionFactory
  return this.sqlSessionFactory;
}

创建SqlSessionFactory，这个方法实现的是InitializingBean的方法

//org.mybatis.spring.SqlSessionFactoryBean#afterPropertiesSet
public void afterPropertiesSet() throws Exception {
  notNull(dataSource, "Property 'dataSource' is required");
  notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
  state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
      "Property 'configuration' and 'configLocation' can not specified with together");
  //创建SqlSessionFactory并赋值给成员变量
  this.sqlSessionFactory = buildSqlSessionFactory();
}

//org.mybatis.spring.SqlSessionFactoryBean#buildSqlSessionFactory
protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
  //mybatis的全局配置
  final Configuration targetConfiguration;
  //mybatis的xml解析器，用来解析xml文件
  XMLConfigBuilder xmlConfigBuilder = null;
  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，创建Configration
    xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
    //赋值Configration
    targetConfiguration = xmlConfigBuilder.getConfiguration();
  } else {
    LOGGER.debug(
        () -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
    //创建一个新的配置
    targetConfiguration = new Configuration();
    Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
  }

  Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
  Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
  Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);
  //注册typeAliases
  if (hasLength(this.typeAliasesPackage)) {
    scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()
        .filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())
        .filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
  }
  //注册typeAliases
  if (!isEmpty(this.typeAliases)) {
    Stream.of(this.typeAliases).forEach(typeAlias -> {
      targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
      LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
    });
  }
  //注册插件
  if (!isEmpty(this.plugins)) {
    Stream.of(this.plugins).forEach(plugin -> {
      targetConfiguration.addInterceptor(plugin);
      LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
    });
  }
  //注册typeHandlers
  if (hasLength(this.typeHandlersPackage)) {
    scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass())
        .filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))
        .forEach(targetConfiguration.getTypeHandlerRegistry()::register);
  }
  //注册typeHandlers
  if (!isEmpty(this.typeHandlers)) {
    Stream.of(this.typeHandlers).forEach(typeHandler -> {
      targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
      LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
    });
  }
  //注册数据库
  if (!isEmpty(this.scriptingLanguageDrivers)) {
    Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {
      targetConfiguration.getLanguageRegistry().register(languageDriver);
      LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");
    });
  }
  Optional.ofNullable(this.defaultScriptingLanguageDriver)
      .ifPresent(targetConfiguration::setDefaultScriptingLanguage);

  if (this.databaseIdProvider != null) {// fix #64 set databaseId before parse mapper xmls
    try {
      targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
    } catch (SQLException e) {
      throw new NestedIOException("Failed getting a databaseId", e);
    }
  }

  Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);

  if (xmlConfigBuilder != null) {
    try {
      //解析配置文件，和篇1一样
      xmlConfigBuilder.parse();
      LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");
    } catch (Exception ex) {
      throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
    } finally {
      ErrorContext.instance().reset();
    }
  }
  //设置环境
  targetConfiguration.setEnvironment(new Environment(this.environment,
      this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,
      this.dataSource));

  if (this.mapperLocations != null) {
    if (this.mapperLocations.length == 0) {
      LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");
    } else {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }
        try {
          //解析mapper
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }
        LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
      }
    }
  } else {
    LOGGER.debug(() -> "Property 'mapperLocations' was not specified.");
  }
  //构建sqlSessionFactory，返回DefaultSqlSessionFactory
  return this.sqlSessionFactoryBuilder.build(targetConfiguration);
}

2、MapperScannerConfigurer

MapperScannerConfigurer的继承关系

MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware

实现了BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，注册mapper接口

//org.mybatis.spring.mapper.MapperScannerConfigurer#postProcessBeanDefinitionRegistry
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  if (this.processPropertyPlaceHolders) {
    processPropertyPlaceHolders();
  }
  //设置scanner的属性
  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);
  scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
  if (StringUtils.hasText(lazyInitialization)) {
    scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
  }
  scanner.registerFilters();
  //扫描配置的mapper的包，可配置多个 以",; \t\n"分隔 
  scanner.scan(
      StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}

注册mapperScanner

//org.mybatis.spring.mapper.MapperScannerConfigurer#processPropertyPlaceHolders
private void processPropertyPlaceHolders() {
  Map<String, PropertyResourceConfigurer> prcs = applicationContext.getBeansOfType(PropertyResourceConfigurer.class);

  if (!prcs.isEmpty() && applicationContext instanceof ConfigurableApplicationContext) {
    BeanDefinition mapperScannerBean = ((ConfigurableApplicationContext) applicationContext).getBeanFactory()
        .getBeanDefinition(beanName);

    // PropertyResourceConfigurer does not expose any methods to explicitly perform
    // property placeholder substitution. Instead, create a BeanFactory that just
    // contains this mapper scanner and post process the factory.
    //注册mapperScanner
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    factory.registerBeanDefinition(beanName, mapperScannerBean);

    for (PropertyResourceConfigurer prc : prcs.values()) {
      prc.postProcessBeanFactory(factory);
    }

    PropertyValues values = mapperScannerBean.getPropertyValues();
	//设置配置的属性
    this.basePackage = updatePropertyValue("basePackage", values);
    this.sqlSessionFactoryBeanName = updatePropertyValue("sqlSessionFactoryBeanName", values);
    this.sqlSessionTemplateBeanName = updatePropertyValue("sqlSessionTemplateBeanName", values);
    this.lazyInitialization = updatePropertyValue("lazyInitialization", values);
  }
  this.basePackage = Optional.ofNullable(this.basePackage).map(getEnvironment()::resolvePlaceholders).orElse(null);
  this.sqlSessionFactoryBeanName = Optional.ofNullable(this.sqlSessionFactoryBeanName)
      .map(getEnvironment()::resolvePlaceholders).orElse(null);
  this.sqlSessionTemplateBeanName = Optional.ofNullable(this.sqlSessionTemplateBeanName)
      .map(getEnvironment()::resolvePlaceholders).orElse(null);
  this.lazyInitialization = Optional.ofNullable(this.lazyInitialization).map(getEnvironment()::resolvePlaceholders)
      .orElse(null);
}

扫描

//org.springframework.context.annotation.ClassPathBeanDefinitionScanner#scan
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);
}

调用子类ClassPathMapperScanner的方法

//org.mybatis.spring.mapper.ClassPathMapperScanner#doScan
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
  //org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
  //将包下面的接口全部注册，beanName，beanDefinition
  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;
}

处理刚注册的BeanDefinition

//org.mybatis.spring.mapper.ClassPathMapperScanner#processBeanDefinitions
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();
      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
      //private Class<? extends MapperFactoryBean> mapperFactoryBeanClass = MapperFactoryBean.class;
      //将bean的类设置为MapperFactoryBean
      definition.setBeanClass(this.mapperFactoryBeanClass);

      definition.getPropertyValues().add("addToConfig", this.addToConfig);
	  //下面会设置一些属性
      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);
    }
  }
2.1、MapperFactoryBean
MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T>

MapperFactoryBean继承SqlSessionDaoSupport，SqlSessionDaoSupport里面封装了SqlSessionTemplate

MapperFactoryBean实现了FactoryBean，会实现getObject()方法

getObject()方法会获取mapper

//org.mybatis.spring.mapper.MapperFactoryBean#getObject
public T getObject() throws Exception {
  return getSqlSession().getMapper(this.mapperInterface);
}

调用SqlSessionDaoSupport获取SqlSession，就是sqlSessionTemplate

//org.mybatis.spring.support.SqlSessionDaoSupport#getSqlSession
public SqlSession getSqlSession() {
  return this.sqlSessionTemplate;
}

调用SqlSessionTemplate获取mapper，往后就和普通的mybatis一样了

//org.mybatis.spring.SqlSessionTemplate#getMapper
public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
}

3、SqlSessionTemplate

SqlSessionTemplate继承关系

SqlSessionTemplate implements SqlSession, DisposableBean

SqlSessionTemplate的构造方法

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
  notNull(executorType, "Property 'executorType' is required");
  //设置属性
  this.sqlSessionFactory = sqlSessionFactory;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
  //反射调用SqlSessionInterceptor
  this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
      new Class[] { SqlSession.class }, new SqlSessionInterceptor());
}

这是一个内部类，实现了jdk的InvocationHandler，用来动态代理

//org.mybatis.spring.SqlSessionTemplate.SqlSessionInterceptor
private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    //反射调用sqlSession相关的sql方法，之后和普通的mybatis一样
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator
              .translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

获取SqlSession

//org.mybatis.spring.SqlSessionUtils#getSqlSession
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
  notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);

  SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

  SqlSession session = sessionHolder(executorType, holder);
  if (session != null) {
    return session;
  }

  LOGGER.debug(() -> "Creating a new SqlSession");
  //利用DefaultSqlSessionFactory开启会话
  session = sessionFactory.openSession(executorType);

  registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

  return session;
}
Mybatis系列-tkmybatis源码分析-01-mybatis、mybatis-spring和tkmybatis的关系
u011923621的博客
04-30 2010
mybatis、mybatis-spring和tkmybatis的关系 定义 MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 MyBatis-Spring 会帮助你...
Mybatis源码解析之Spring集成mybatis-spring分析
翻身已碰头的博客
03-21 1131
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 Mybatis源码解析之缓存机制（一）：一级缓存 Mybatis源码解析之缓存机制（二）：二级缓存 Mybatis源码解析之插件机制 前面的几篇相关博客都针对原生的mybatis进行解析，从本文开始将针对myba...
SpringBoot整合MybatisPlus存在Mapper运行时报错
攻城狮Chova的博客
11-21 1538
SpringBoot中mapper注入失败异常信息原因解决办法@Mapper@MapperScan 异常信息 在SpringBoot运行测试Mybatis-Plus测试的时候报错: rg.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'com.oxford....
解决spring整合mybatis时错误 ‘org.mybatis.spring.mapper.MapperScannerConfigurer#0‘
卉卉的博客
04-13 2406
org/springframework/dao/support/DaoSupport
Error creating bean with name ‘org.mybatis.spring.mapper.MapperScannerConfigurer#0‘ defined in class
qq_45220508的博客
03-28 1979
java.lang.NoClassDefFoundError:org/springframework/dao/support/DaoSupport
【Java】NoClassDefFoundError: org/mybatis/logging/LoggerFactory
微信公众号: 后端码匠
12-31 1万+
完整错误 org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'userServiceImpl': Unsatisfied dependency expressed through field 'baseMapper'; nested exception is org.springframework.beans.factory.UnsatisfiedDependency
AnnotationFormatError : org.mybatis.spring.annotation.MapperScan.factoryBean
jiang_zf的博客
04-22 1万+
声明下，报这个错的原因可能很多，这个可能只是其中的原因之一，大家可以试下看看自己是不是这个原因。 SpringBoot集成MybatisPlus，启动的时候总是报如下错误： java.lang.annotation.AnnotationFormatError: Invalid default: public abstract java.lang.Class org.mybatis.spring...
深入 MyBatis-Spring 源码解析 ——揭秘 MyBatis 与 Spring 的完美融合
喵手的博客
12-09 1465
当谈到 Java 的持久层框架，MyBatis 几乎总会出现在讨论中；它轻量、灵活，非常适合需要复杂 SQL 查询的场景。而我们的大管家 Spring，除了帮我们管理依赖和控制反转之外，还可以跟 MyBatis 完美地配合在一起！这就是我们今天要讨论的主题——。在这个分析中，我们将通过源码来揭秘 MyBatis-Spring 是如何在两者间架起桥梁的，希望让你对其工作原理有一个深入的理解。MyBatis-Spring 是 Spring 提供的一个适配器模块，它的目标是帮助开发者在 Spring 应用中。
Mybatis源码解析之SpringBoot集成mybatis-spring-boot-starter分析
翻身已碰头的博客
03-28 1万+
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 Mybatis源码解析之缓存机制（一）：一级缓存 Mybatis源码解析之缓存机制（二）：二级缓存 Mybatis源码解析之插件机制 Mybatis源码解析之mapper接口的代理模式 Mybatis源码解析之D...
Java架构师之源码分析专题SpringBoot2.x、Spring5、SpringMVC、Mybatis源码分析
08-23
最后，Mybatis作为持久层框架，它的源码分析主要集中在SQL映射文件的解析，动态SQL的生成，以及与数据库的交互。你将了解到Executor执行器的执行策略，StatementHandler如何处理SQL语句，以及ResultHandler如何处理...
Mybatis集成Spring原理分析
lemon
03-01 1903
概述 MapperFactoryBean扩展SqlSessionDaoSupport SqlSessionDaoSupport可以设置SqlSessionFactory或SqlSessionTemplate，对于设置SqlSessionFactory会包装成SqlSessionTemplate SqlSessionTemplate实现了SqlSession接口，实例化SqlSessionTe...
Spring与MyBatis整合源码分析
我神级欧文的博客
10-02 2275
Spring与MyBatis整合原理 先来说说我们通常使用在Spring环境中使用MyBatis的步骤： 加上mybatis-spring的maven坐标 在启动类上加@MapperScan注解，在注解中标明你要扫描的mapper的包路径 在service上使用spring的@Autowired注解把想要的mapper注入进service中 可能大家一直觉得挺神奇的一点就是，在我们不在spring环境中单独使用MyBatis的时候，mapper对象是我们手动去通过调用sqlsession.g.
mybatis-spring
02-16 879
mybatis 整合spring基础mybatis是通过sqlSessionFactoryBuilder 创建sqlSessionFactory。而在mybatis-spring中，是通过sqlSessionFactoryBean创建。
mybatis-spring原理解析
qq_28695733的博客
06-29 1637
mybatis-spring解析 概述 mybatis-spring让mybatis和Spring无缝对接，无需再关心mybatis中的Configuration、SqlSessionFactory、SqlSession，自动为Mapper创建实例注册到SpringIoc容器中， 并由Spring事务管理。在使用spring的前提下更加简化了Mybatis的操作，使用过程不用关心任何mybatis的相关概念。 Mybatis-spring主要做的内容包含： mybatis相关类 “Spri.
mybatis整合spring时出现：Error creating bean with name 'org.mybatis.spring.mapper.MapperScannerConfigurer
热门推荐
M10F的博客
04-12 2万+
mybatis整合spring时出现如下错误 错误：Error creating bean with name 'org.mybatis.spring.mapper.MapperScannerConfigurer#0' defined in class path resource [applicationContext.xml]: Cannot resolve reference to be...
解决错误Error creating bean with name 'MySessionFactory' defined in class path resource [applicationContext.xml]: Invocation of init
王康的技术博客
03-15 8942
<br /><br />log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).<br />log4j:WARN Please initialize the log4j system properly.<br />log4j:WARN See http://logging.apache.org/log4j/1.2/faq.htm
[org.mybatis.spring.mapper.ClassPathMapperScanner]-No MyBatis mapper was found in '[com.xxx.xxx.dao]
weixin_33676492的博客
01-16 6165
版权声明：本文为 testcs_dn(微wx笑) 原创文章，非商用自由转载-保持署名-注明出处，谢谢。 https://blog.csdn.net/testcs_dn/article/details/79074633 项目启动后，控制台输...
springboot启动 Logback报错---ERROR in ch.qos.logback.classic.joran.action.ContextNameAction
最新发布
时光里的博客
12-12 2072
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
Error creating bean with name 'org.mybatis.spring.mapper.ClassPathMapperScanner#0' defined in file
wangxiaohua_147的博客
10-27 2700
解决方案：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值