Spring Mybatis 启动，执行过程 源码Debug

最新推荐文章于 2022-12-03 22:47:56 发布
最新推荐文章于 2022-12-03 22:47:56 发布
阅读量1.2k 收藏 1
点赞数 2
文章标签： Spring Mybatis 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cmmchenmm/article/details/85341850
版权

版本信息

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.3.2</version>
</dependency>
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.8.RELEASE</version> <!-- lookup parent from repository -->
</parent>

从SqlSession讲起

SqlSession 来自 SqlSessionFactory 来自 SqlSessionFactoryBean

我们先看看 SqlSessionFactoryBean

SqlSessionFactoryBean

Class 信息定义如下

public class SqlSessionFactoryBean implements 
		FactoryBean<SqlSessionFactory>, 
		InitializingBean, 
		ApplicationListener<ApplicationEvent> {
	...
}

因为实现了 FactoryBean<SqlSessionFactory> 接口所以可以看相关接口代码实现

@Override
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");
	
	this.sqlSessionFactory = buildSqlSessionFactory();
}

@Override
public SqlSessionFactory getObject() throws Exception {
	if (this.sqlSessionFactory == null) {
	  afterPropertiesSet();
	}
	
	return this.sqlSessionFactory;
}

@Override
public Class<? extends SqlSessionFactory> getObjectType() {
    return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
}

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

由上述代码可知，当我们执行SqlSessionFactoryBean#getObject()时会执行SqlSessionFactoryBean#afterPropertiesSet()

即 当属性注入完成之后，放置到容器之前的生命周期阶段 类似于 JSR250 中的 @PostConstruct
这样会不会导致重复执行 SqlSessionFactoryBean#afterPropertiesSet() 或者说重复执行该方法是否效果一样（幂等）

是否幂等主要还是要看 SqlSessionFactoryBean#buildSqlSessionFactory() 方法 我们来看看这个是怎么操作的

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configuration != null) {
      configuration = this.configuration;
      if (configuration.getVariables() == null) {
        configuration.setVariables(this.configurationProperties);
      } else if (this.configurationProperties != null) {
        configuration.getVariables().putAll(this.configurationProperties);
      }
    } else if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
      }
      configuration = new Configuration();
      if (this.configurationProperties != null) {
        configuration.setVariables(this.configurationProperties);
      }
    }

    if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }

    if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }

    if (this.vfs != null) {
      configuration.setVfsImpl(this.vfs);
    }

    if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeAliasPackageArray) {
        configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
        }
      }
    }

    if (!isEmpty(this.typeAliases)) {
      for (Class<?> typeAlias : this.typeAliases) {
        configuration.getTypeAliasRegistry().registerAlias(typeAlias);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type alias: '" + typeAlias + "'");
        }
      }
    }

    if (!isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins) {
        configuration.addInterceptor(plugin);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered plugin: '" + plugin + "'");
        }
      }
    }

    if (hasLength(this.typeHandlersPackage)) {
      String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeHandlersPackageArray) {
        configuration.getTypeHandlerRegistry().register(packageToScan);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
        }
      }
    }

    if (!isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers) {
        configuration.getTypeHandlerRegistry().register(typeHandler);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type handler: '" + typeHandler + "'");
        }
      }
    }

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

    if (this.cache != null) {
      configuration.addCache(this.cache);
    }

    if (xmlConfigBuilder != null) {
      try {
        xmlConfigBuilder.parse();

        if (LOGGER.isDebugEnabled()) {
          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();
      }
    }

    if (this.transactionFactory == null) {
      this.transactionFactory = new SpringManagedTransactionFactory();
    }

    configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }

        try {
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              configuration, mapperLocation.toString(), configuration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
        }
      }
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
      }
    }
	//构建代码核心，创建一个SqlSession 代码如下
    return this.sqlSessionFactoryBuilder.build(configuration);
  }
  
  //org.apache.ibatis.session.SqlSessionFactoryBuilder
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

可以看到代码中加了很多的null值的判断，不知道是否是为了代码复用才这样设计的
而且看出默认是使用DefaultSqlSessionFactory这个实现类型

说到了 SqlSessionFactoryBuilder.build 我们看一下这个方法的一些重载方法

public class SqlSessionFactoryBuilder {

  public SqlSessionFactory build(Reader reader) {
    return build(reader, null, null);
  }

  public SqlSessionFactory build(Reader reader, String environment) {
    return build(reader, environment, null);
  }

  public SqlSessionFactory build(Reader reader, Properties properties) {
    return build(reader, null, properties);
  }

  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

  public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
  }

  public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }
    
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

}

可以看到我们可以根据文件流来构建SqlSessionFactory对象
多个流形式的操作均最后使用了以下代码获取到 XMLConfigBuilder

XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);


//org.apache.ibatis.builder.xml.XMLConfigBuilder
public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

最终还是利用了Configuration对象进行构建SqlSession

可以目测一下在 Spring Boot 环境上应该是使用了 MybatisAutoConfiguration 进行配置
我们可以简单的看一下 MybatisAutoConfiguration这个类

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnBean(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MybatisAutoConfiguration {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List<ConfigurationCustomizer> configurationCustomizers;

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

基本上就使用了 Spring/Spring Boot 代码配置的相关注解

  • 基本解读就是 SqlSessionFactory SqlSessionFactoryBean 这两个类的配置需要存在
  • 存在DataSource这个类的对象
  • 需要加载MybatisProperties配置
  • 在DataSourceAutoConfiguration配置完成之后才进行加载

我们看看 MybatisProperties的类信息

@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties {
	... 
	//在 application.properties 中配置就注入到这里面了
}

可以顺带看看如何获取到SqlSessionFactory的代码

@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()));
    }
    Configuration configuration = this.properties.getConfiguration();
    if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
      configuration = new Configuration();
    }
    if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
      for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
        customizer.customize(configuration);
      }
    }
    factory.setConfiguration(configuration);
    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 (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

    return factory.getObject();
 }

以上代码可以看出貌似未将SqlSessionFactoryBean类对象交由 Spring 的容器进行托管

MapperProxyFactory 构建接口代理

org.apache.ibatis.session.Configuration.getMapper(Class,SqlSession)

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
}

看看 mapperRegistry.getMapper(type, sqlSession);做了什么动作

org.apache.ibatis.binding.MapperRegistry

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);
    }
}

上述两段代码中的 Class 参数 均为需要被代理的接口字节码对象
所以关键步骤就是 mapperProxyFactory.newInstance(sqlSession); 这段代码

其中

  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = 
  new HashMap<Class<?>, MapperProxyFactory<?>>();

就是在本地 MapperProxyFactory 缓存中获取 MapperProxyFactory对象进行代理操作

org.apache.ibatis.binding.MapperProxyFactory

public class MapperProxyFactory<T> {

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

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

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

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

  //可以看出关键步骤就是执行JDK动态代理，目测 MapperProxy 实现了 InvocationHandler 接口
  @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<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

}

org.apache.ibatis.binding.MapperProxy

public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //既没有方法实现，也没有默认实现则使用 cachedMapperMethod 方法获取 MapperMethod 执行
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    //在对象内部进行了代理方法的缓存 
    //大致为一个Mapper接口 有一个MapperProxy对象
    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

  // 难道是因为Java8之后接口可以有默认的实现方法，所以来了一个 UsesJava7 走默认实现
  @UsesJava7
  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

  /**
   * Backport of java.lang.reflect.Method#isDefault()
   */
  private boolean isDefaultMethod(Method method) {
    return (method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
        && method.getDeclaringClass().isInterface();
  }
}

最后我们看看 MapperMethod org.apache.ibatis.binding.MapperMethod

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: {
      Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
}

private Object rowCountResult(int rowCount) {
    final Object result;
    if (method.returnsVoid()) {
      result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
      result = (long)rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
      result = rowCount > 0;
    } else {
      throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    return result;
}

...

最终执行的大致逻辑就是根据SQL语句和xml当中标签执行jdbc代码

NewshiJ
关注
SpringBoot快速集成Mybatis并轻松上手调试
Blake的博客
04-08 786
本篇主题：SpringBoot如何快速集成Mybatis并上手调试？ 引入相关Jar依赖 这里使用Gradle作为构建工具,构建脚本build.gradle见下图： 事实上，SpringBoot与Mybatis的集成由 org.mybatis.spring.boot:mybatis-spring-boot-starter:2.0.0 完成。因此，org.mybatis.spring.bo...
ShardingJdbc、Spring和mybatis结合的整个源码执行流程解析
betterMan的专栏
11-08 2495
#一.背景知识 ###1.Sharding jdbc 当当提供的轻量级java框架，通过客户端进行分库分表策略执行等操作，直连到数据库 http://shardingsphere.io/document/current/cn/overview/ ###2.Spring 项目给于spring提供的事务管理和springBoot带来的快速启动 ###3.Mybatis和Mybatis-Spring 使...
mybatis_debug:调试mybatis，spring
03-24
mybatis_debug:调试mybatis，spring源码
spring加载mybatis启动流程简介
名猿陈大浏的博客
06-01 1575
第一步：首先看看mybatis在spring里的两个关键配置项 <!-- 1.配置sqlSessionFactory --> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="configLocation" value="WEB-INF/mybatis-config.xml" /> <property name=
mybatis系列----启动流程
qq_33012981的博客
12-18 948
mybatis系列–1–启动流程 文章目录`mybatis`系列--`1`--启动流程1 前言2 原生`jdbc`3 `mybatis`的简单用法4 启动流程4.1 `SqlSessionFactoryBuilder().build(inputStream)`4.1.1 `configurationElement(parser.evalNode("/mapper"))`4.1.2 `bindMapperForNamespace()`4.2 `sqlSessionFactory.openSession()
springboot+mybatis-plus 增删改查pom.xml依赖
lzj1448215859的博客
11-14 297
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/ma.
Spring整合Mybatis全过程解析
qq3164069700的博客
12-08 1854
MyBatis 是一款常用的持久层框架，使得程序能够以调用方法的方式执行某个指定的SQL，将执行SQL的底层逻辑进行封装。多数与Spring结合使用，本文讨论Spring如何整合Mybatis，首先看下Mybatis运行机制 1. Mybatis运行机制 1.1 Mybatis功能架构设计 Mybatis的功能架构分为三层： (1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。 (2)数据处理层：负责
Mybatis源码解析之Spring集成mybatis-spring分析
翻身已碰头的博客
03-21 1078
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 Mybatis源码解析之缓存机制（一）：一级缓存 Mybatis源码解析之缓存机制（二）：二级缓存 Mybatis源码解析之插件机制 前面的几篇相关博客都针对原生的mybatis进行解析，从本文开始将针对myba...
jdbc/mybatis使用及Spring-mybatis整合源码分析
ppprog的博客
08-09 203
本文主要对 JDBC连接db / Spring-JDBC连接db / Mybatis独立使用 / Spring整合Mybatis 几种db连接和使用的过程作出总结，并对其中的关键环节进行源码分析。 事务部分暂时还没整理，后面会补全。 部分配置文件还没加上，后面会补全。 说明：文中大部分内容来源于阅读《Spring源码深度解析》时的笔记，同时添加了一些自己的理解。书中使用的Spring 5.x版本，代码有点老，但核心原理一直都差不多。 1 JDBC连接db 一般流程 在开发环境加载指定db的驱动程序 在ja
springboot配置文件开启mybatis得debug日志配置
SoWhatWorld的博客
05-06 2046
application.yml文件中开启： logging: level: com.spot.cn.mapper: debug
Mybatis中的Dao接口和XML文件里的SQL是如何建立关系的
Jesse_cool的博客
04-10 7848
看到阿里这道面试题的时候，我就知道是时候看下mybatis源码了准...
mybatis-spring启动流程源码
qq_35219329的博客
07-05 354
目录 前言 二、扫描Mapper接口，注册Bean定义 1.@MapperScan 2.MapperScannerConfigurer 三、实例化MapperFactoryBean 总结 前言 在上一篇文章中分析了mybatis的启动流程，主要包括SqlSessionFactory的创建和configure配置文件的解析，然后是sqlSession的创建，最后完成了mapper动态代理对象的创建，本文主要分析在有spring参与的情况下，mybatis的启动流程。 一、启动配...
springboot 之 集成MyBatis配置debug时log打印到控制台
m0_67402341的博客
04-25 709
application.properties(yml)中配置的两种方式 1. logging.level.yourdaoclasspackagename=debug 2. mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl 这两种方式的效果是一样的，但是上面一种可以指定某个包下的SQL打印出来，下面这个会全部的都会打印出来。 ...
mybatis执行过程分析
yang_yang_6666的博客
01-14 521
装载到spring bean容器 把扫描到的mapper加载到beanfactory中BeanDefinition Map中 通过修改BeanDefinition 使用MapperProxyFactory 创建mapper的代理对象 加载到spring bean容器中 执行sql过程 通过MapperProxy代理对象调用MapperMethod 执行sql查询 public Object...
Mybatis+Springboot实现分页【debug——传值】
ElyXiOn的博客
09-21 219
Mybatis+Springboot实现分页【debug——传值】
spring boot 应用mybatis
最新发布
喵酱
12-03 1530
spring boot 应用mybatis
SpringBoot 开启 Mybatis 日志
web13618542420的博客
04-25 1137
SpringBoot 开启 Mybatis 日志 在properties新增： logging.level.org.sysu.rain.Mapper=debug 注意：其中org.sysu.rain是Mapper包位置 等号后面是日志等级。
mybatis与spring整合详解
debug
01-25 260
1. 引言 2. 传统JDBC代码的弊端 3. 配置数据源 3.1. 使用简单数据库配置 3.2. 使用第三方数据连接池(DBCP) 4. MyBatis-Spring项目配置 4.1. 配置Spring-MyBatis项目的步骤 4.2. 配置SqlSessionFactoryBean 4.3. 配置MapperFactoryBean 4.4. 配置MapperScannerConf...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值