超详细解释MyBatis与Spring的集成原理

最新推荐文章于 2024-09-23 08:47:08 发布
最新推荐文章于 2024-09-23 08:47:08 发布
阅读量531 收藏 5
点赞数 1
分类专栏： java 文章标签： mybatis spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71777195/article/details/129224916
版权
java 专栏收录该内容
3549 篇文章 121 订阅
订阅专栏

前言

最原始的MyBatis的使用，通常有如下几个步骤。

  1. 读取配置文件mybatis-config.xml构建SqlSessionFactory；
  2. 通过SqlSessionFactory拿到SqlSession；
  3. 通过SqlSession拿到Mapper接口的动态代理对象；
  4. 通过Mapper接口的动态代理对象执行SQL语句；
  5. 关闭SqlSession。

那么当MyBatis集成到Spring中时，上述的一些对象应该会被Spring容器来管理。本篇文章将对MyBatis集成到Spring中时的关键原理进行学习。

正文

一. MyBatis关键对象生命周期

在单独使用MyBatis时，使用到了几个关键对象，分别是：SqlSessionFactoryBuilder，SqlSessionFactory，SqlSession和Mapper接口实例。下面给出这几个关键对象的生命周期。

对象生命周期说明
SqlSessionFactoryBuilder方法局部用于创建SqlSessionFactory，当SqlSessionFactory创建完毕后，就不再需要SqlSessionFactoryBuilder了
SqlSessionFactory应用级别用于创建SqlSession，由于每次与数据库进行交互时，需要先获取SqlSession，因此SqlSessionFactory应该是单例并且与应用生命周期保持一致
SqlSession请求或操作用于访问数据库，访问前需要通过SqlSessionFactory创建本次访问所需的SqlSession，访问后需要销毁本次访问使用的SqlSession，所以SqlSession的生命周期是一次请求的开始到结束
Mapper接口实例方法Mapper接口实例通过SqlSession获取，所以Mapper接口实例的生命周期最长可以与SqlSession相等，同时Mapper接口实例的最佳生命周期范围应该是方法范围，即在一个方法中通过SqlSession获取到Mapper接口实例并执行完逻辑后，该Mapper接口实例就应该被丢弃

二. 思考几个问题

如果要实现MyBatis与Spring的集成，那么就需要解决单独使用MyBatis时的几个关键对象的生命周期管理，重点考虑SqlSessionFactory，SqlSession和Mapper接口实例。下面罗列出需要思考的问题。

  1. SqlSessionFactory在什么时候创建；
  2. SqlSession如何获取；
  3. Mapper接口实例如何生成。

三. Spring集成MyBatis示例

在Spring中集成MyBatis，其核心思想就是将单独使用MyBatis时的关键对象交给Spring容器管理，下面看一下Spring集成MyBatis时的配置类，如下所示。

@Configuration
@ComponentScan(value = "扫描包路径")
public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory() throws Exception{
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(pooledDataSource());
        sqlSessionFactoryBean.setConfigLocation(new ClassPathResource("Mybatis配置文件名"));
        return sqlSessionFactoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("映射接口包路径");
        return msc;
    }

    // 创建一个数据源
    private PooledDataSource pooledDataSource() {
        PooledDataSource dataSource = new PooledDataSource();
        dataSource.setUrl("数据库URL地址");
        dataSource.setUsername("数据库用户名");
        dataSource.setPassword("数据库密码");
        dataSource.setDriver("数据库连接驱动");
        return dataSource;
    }

}
复制代码

如上所示，Spring集成MyBatis时，需要向容器注册SqlSessionFactoryBean（实际就是注册SqlSessionFactory）和MapperScannerConfigurer的bean实例，那么下面就从这两个对象开始分析，Spring是如何集成MyBatis的。

四. SqlSessionFactory的创建源码分析

SqlSessionFactoryBean类图如下所示。

重点关心SqlSessionFactoryBean实现的InitializingBean和FactoryBean接口。首先是InitializingBean接口，在SqlSessionFactoryBean的初始化阶段会调用到SqlSessionFactoryBean实现的afterPropertiesSet() 方法，实现如下。

public void afterPropertiesSet() throws Exception {
    
    // ......

    // 创建SqlSessionFactory
    this.sqlSessionFactory = buildSqlSessionFactory();
}
复制代码

在SqlSessionFactoryBean的afterPropertiesSet() 方法中会调用到buildSqlSessionFactory() 方法来创建SqlSessionFactory，buildSqlSessionFactory() 方法顾名思义，就是创建SqlSessionFactory，由于该方法很长，就不贴出其实现，总的步骤概括如下。

  1. 创建XMLConfigBuilder；
  2. 使用XMLConfigBuilder解析MyBatis配置文件，得到MyBatis全局配置类Configuration；
  3. 使用SqlSessionFactoryBuilder基于Configuration创建SqlSessionFactory。

在得到SqlSessionFactory后就会将其赋值给SqlSessionFactoryBean的sqlSessionFactory字段。现在又已知SqlSessionFactoryBean实现了FactoryBean接口，那么SqlSessionFactoryBean实际作用是构建复杂的bean，这个复杂的bean通过SqlSessionFactoryBean的getObject() 方法获取，实现如下。

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

    return this.sqlSessionFactory;
}
复制代码

那么SqlSessionFactoryBean的作用实际就是解析配置文件并构建得到SqlSessionFactory，并最终将SqlSessionFactory放入Spring容器中。

五. SqlSession和Mapper实例创建源码分析

通过分析SqlSessionFactoryBean知道了SqlSessionFactoryBean会构建SqlSessionFactory并放到Spring容器中，那么有了SqlSessionFactory，现在要和数据库交互还需要SqlSession以及Mapper接口实例，但是如果只是单纯的将SqlSession和Mapper接口实例创建出来并放入Spring容器，那么肯定会引入线程不安全的问题，所以在Spring集成MyBatis中，肯定对SqlSession和Mapper接口实例有特殊处理，所以下面继续分析MapperScannerConfigurer， 来探究Spring如何管理SqlSession和Mapper接口实例。

MapperScannerConfigurer的类图如下所示。

由类图可知，MapperScannerConfigurer其实是一个bean工厂后置处理器，其会扫描配置的包路径下的所有Mapper接口并为这些Mapper接口生成BeanDefinition并缓存起来，为接口生成BeanDefinition，那么MyBatis肯定做了特殊处理，才能够让Mapper接口对应的BeanDefinition也能够创建bean，所以下面看一下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);
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
        scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    if (StringUtils.hasText(defaultScope)) {
        scanner.setDefaultScope(defaultScope);
    }
    scanner.registerFilters();
    // 委托给ClassPathBeanDefinitionScanner进行扫描得到BeanDefinition
    // 然后ClassPathMapperScanner对得到的BeanDefinition进行特殊处理
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, 
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
复制代码

MapperScannerConfigurer将扫描指定包并得到BeanDefinition的逻辑委托给了ClassPathBeanDefinitionScanner，然后又在ClassPathMapperScanner中完成了对Mapper接口对应的BeanDefinition的特殊处理，特殊处理的方法在ClassPathMapperScanner的processBeanDefinitions() 方法中，由于该方法也特别长，下面仅将关键部分罗列出来。

AbstractBeanDefinition definition;

// ......

// 将bean的Class对象设置为MapperFactoryBean的Class对象
definition.setBeanClass(this.mapperFactoryBeanClass);
复制代码

其实processBeanDefinitions()中的特殊处理最关键的就是将BeanDefinition的Class对象设置为了MapperFactoryBean.class，那么后续基于所有Mapper接口的BeanDefinition来创建bean时，创建出来的bean的类型为MapperFactoryBean，下面先看一下MapperFactoryBean的类图。

通过类图可以发现，MapperFactoryBean中有一个sqlSessionFactory属性字段，其类型就是SqlSessionFactory，那么在MapperFactoryBean的生命周期的属性注入阶段，会调用到MapperFactoryBean的setSqlSessionFactory() 方法来设置sqlSessionFactory属性字段的值，但其实MapperFactoryBean和其父类中是没有sqlSessionFactory属性字段的，但是却提供了sqlSessionFactory属性字段的get() 和set() 方法，那么这样做的用意是什么呢，继续看setSqlSessionFactory() 方法以寻求答案，setSqlSessionFactory() 方法在MapperFactoryBean的父类SqlSessionDaoSupport中，如下所示。

// 入参的SqlSessionFactory就是容器中的SqlSessionFactory
public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
    if (this.sqlSessionTemplate == null || sqlSessionFactory != this.sqlSessionTemplate.getSqlSessionFactory()) {
        this.sqlSessionTemplate = createSqlSessionTemplate(sqlSessionFactory);
    }
}
复制代码

现在知道，setSqlSessionFactory() 方法设置sqlSessionFactory属性字段是假，设置sqlSessionTemplate属性字段才是真。sqlSessionTemplate属性字段类型是SqlSessionTemplate，在上面的setSqlSessionFactory() 方法中，会先创建一个SqlSessionTemplate对象，然后赋值给sqlSessionTemplate属性字段，创建SqlSessionTemplate对象的逻辑会一路调用到SqlSessionTemplate的如下构造方法，实现如下。

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

    // ......

    // 将SqlSessionFactory赋值给SqlSessionTemplate的sqlSessionFactory字段
    this.sqlSessionFactory = sqlSessionFactory;
    this.executorType = executorType;
    this.exceptionTranslator = exceptionTranslator;
    // sqlSessionProxy字段类型是SqlSession，并且是一个动态代理对象
    this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
        new Class[] { SqlSession.class }, new SqlSessionInterceptor());
}
复制代码

到这里就知道了，每个Mapper接口在容器中的bean实际是一个MapperFactoryBean对象（暂且这么认为，因为MapperFactoryBean实际上还是一个FactoryBean，它实际会将其getObject() 方法的返回值作为Mapper接口在容器中的bean，这个bean就是MyBatis为Mapper接口生成的动态代理对象，这一点后面再分析），每创建一个MapperFactoryBean对象都会new一个SqlSessionTemplate对象，每new一个SqlSessionTemplate对象，就会通过JDK动态代理生成一个SqlSession的动态代理对象，那么现在再看一下SqlSession的动态代理对象中的InvocationHandler（实际为SqlSessionInterceptor）的invoke() 方法的逻辑，如下所示。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 从Spring事务管理器获取SqlSession
    // 如果当前存在事务，则从当前事务中获取SqlSession
    // 如果获取到的SqlSession为空，则通过SqlSessionFactory新建一个SqlSeesion，并将这个SqlSeesion与事务同步
    SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
        SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
    try {
        // 这里没有执行被代理的SqlSession的方法
        // 而是执行从Spring事务管理器获取到的SqlSession的方法
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
            // 如果SqlSession不由Spring事务管理器管理，则这里在关闭SqlSession前主动提交一次事务
            sqlSession.commit(true);
        }
        return result;
    } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
            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) {
            // 如果SqlSession不由Spring事务管理器管理，则在这里关闭SqlSession
            closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
    }
}
复制代码

上述invoke() 方法中的逻辑是，每次调用到invoke() 方法，都会从Spring事务管理器获取SqlSession，然后执行获取到的SqlSession的方法，并且invoke() 方法的最后还会对获取到的SqlSession执行关闭逻辑，那么这里就知道了两件事情。

  1. 被代理的SqlSession并没有被调用，每次invoke() 方法中调用的都是从Spring事务管理器中获取的SqlSession；
  2. SqlSession的关闭不需要用户操心，每次使用完都会在invoke() 方法的最后被关闭。

那么现在只差最后一步，就可以看清楚Spring集成MyBatis的整体逻辑了，那就是上面提到MapperFactoryBean对象，现在已经知道Mapper接口在容器中的bean是一个MapperFactoryBean对象，但是其实MapperFactoryBean还实现了FactoryBean接口，那么Mapper接口在容器中的bean实际是MapperFactoryBean的getObject() 方法的返回值，下面看一下MapperFactoryBean的getObject() 方法的实现。

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

public SqlSession getSqlSession() {
    return this.sqlSessionTemplate;
}
复制代码

继续看SqlSessionTemplate的getMapper() 方法，如下所示。

public <T> T getMapper(Class<T> type) {
    return getConfiguration().getMapper(type, this);
}
复制代码

SqlSessionTemplate的getMapper() 方法其实和DefaultSqlSession的getMapper() 方法一样，就是通过Configuration的getMapper() 方法为Mapper接口生成动态代理对象，那么现在知道了，Spring集成MyBatis后，MyBatis还是会为每个Mapper接口生成一个动态代理对象并注册到Spring容器中让Spring管理，那么这里Mapper接口的动态代理对象与单独使用MyBatis时的动态代理对象有什么不同，可以概括如下。

  1. 原始使用MyBatis时，Mapper接口的动态代理对象中的SqlSession是通过SqlSessionFactory创建出来的DefaultSqlSession；
  2. Spring集成MyBatis后，Mapper接口的动态代理对象中的SqlSession是SqlSessionTemplate，而SqlSessionTemplate会将请求转发给其持有的sqlSessionProxy，sqlSessionProxy是SqlSession的动态代理对象，每次调用到sqlSessionProxy的方法时，都会在sqlSessionProxy的InvocationHandler的invoke() 方法中从Spring事务管理器中获取SqlSession，并最终调用从Spring事务管理器中获取到的SqlSession的方法。

那么到这里，Spring集成MyBatis的整体逻辑就分析完毕。

六. 问题回答

1. SqlSessionFactory在什么时候创建

通过SqlSessionFactoryBean在Spring容器初始化阶段生成SqlSessionFactory的bean并注册到Spring容器中。

2. SqlSession如何获取

见问题3。

3. Mapper接口实例如何生成

Mapper接口的实例由MapperFactoryBean的getObject() 方法生成，本质还是MyBatis通过Configuration的getMapper() 方法为Mapper接口生成动态代理对象，每个Mapper接口的动态代理对象由Spring容器管理，并且Mapper接口的动态代理对象持有的SqlSession实际为SqlSessionTemplate。

当调用Mapper接口的动态代理对象的方法时，会调用到SqlSessionTemplate的方法，然后SqlSessionTemplate将调用转发到SqlSessionTemplate持有的SqlSession的动态代理对象，然后调用到SqlSession的动态代理对象InvocationHandler的invoke() 方法，在invoke() 方法中会生成SqlSession，所以SqlSession的生成是在Mapper接口的实例的方法被调用时，且每次调用都会生成一个SqlSession。

总结

Spring集成Mybatis时，有几个关键对象，弄清楚这几个关键对象，也就清楚是如何集成的了。

  1. SqlSessionFactoryBean

该对象用于向Spring容器注册SqlSessionFactory的bean，所以Spring集成MyBatis时，SqlSessionFactory存在于Spring容器中，生命周期与Spring应用一致。

  1. MapperFactoryBean

该对象用于为Mapper接口生成动态代理对象，首先是调用到MapperFactoryBean的getObject() 方法，然后调用到SqlSessionTemplate的getMapper() 方法，然后调用到Configuration的getMapper() 方法，后续就是MyBatis为Mapper接口生成动态代理对象的逻辑了。

  1. SqlSessionTemplate

该对象由MapperFactoryBean持有，每个Mapper接口对应一个MapperFactoryBean对象，每个MapperFactoryBean对象对应一个SqlSessionTemplate对象，每个SqlSessionTemplate对象持有全局唯一的SqlSessionFactory对象和一个SqlSession的动态代理对象sqlSessionProxy，SqlSessionTemplate的所有CURD操作都是转发给sqlSessionProxy。

  1. SqlSessionInterceptor

SqlSessionTemplate持有的SqlSession的动态代理对象的InvocationHandler就是一个SqlSessionInterceptor对象，该对象的invoke() 方法会在每次被调用时创建一个SqlSession，然后执行创建出来的SqlSession的方法，并且在invoke() 方法的最后会关闭创建出来的SqlSession。

所以Spring集成MyBatis后，应用程序可以通过注解注入Mapper接口的实例，注入的Mapper接口的实例实际为MyBatis为Mapper接口生成的动态代理对象，调用Mapper接口的实例的方法时，调用请求会发送到SqlSessionTemplate，然后SqlSessionTemplate会将调用请求转发到sqlSessionProxy，然后在sqlSessionProxy的InvocationHandler的invoke() 方法中创建SqlSession，然后调用创建出来的SqlSession的方法，调用完毕后，会在InvocationHandler的invoke() 方法最后关闭创建出来的SqlSession，所以SqlSession的生命周期也是一次请求从开始到结束。

Spring集成MyBatis后，调用Mapper接口的动态代理对象的一次请求时序图如下。

透彻掌握Spring整合MyBatis的原理彻底征服面试官，建议收藏
波波烤鸭的博客
05-31 3520
  在MyBatis篇内容的最后我们来给大家详细介绍下Spring是如何整合MyBatis的。让大家彻底掌握MyBatis的底层设计原理及实现。 MyBatis整合Spring原理   把MyBatis集成到Spring里面，是为了进一步简化MyBatis的使用，所以只是对MyBatis做了一些封装，并没有替换MyBatis的核心对象。也就是说：MyBatis jar包中的SqlSessionFactory、SqlSession、MapperProxy这些类都会用到。mybatis-spring.jar里
Mybatis与Spring集成原理
诺浅的专栏
08-23 3236
原生的Mybatis是怎么使用的？ 只列举关键代码 public static void main(String[] args) throws Exception { Reader reader=Resources.getResourceAsReader("resource/configuration.xml"); SqlSessionFactory sessionFactory=new SqlSessionFactoryBuilder().build(reader); SqlSession sess
Spring-mybatis结合的底层原理
nickel369的博客
07-29 548
通过spring框架底层原理，手写spring和mybatis框架整合的基本原理
MyBatis 集成spring框架
最新发布
Flying_Fish_roe的博客
09-23 1589
MyBatis 与 Spring 的集成为开发者提供了强大的数据持久化解决方案。通过 MyBatis，开发者可以灵活地编写 SQL 并进行高效的数据库交互，而 Spring 的事务管理、依赖注入、AOP 等功能则增强了持久层的管理能力。在实际项目中，可以根据业务需求选择注解或 XML 方式进行 SQL 映射，并利用 Spring 的强大功能实现数据操作的稳定性和可维护性。
spring整合mybatis原理
m0_73671382的博客
04-10 1067
我们先来实现MyBatis和Spring的整合操作。
spring整合mybatis
weixin_45457509的博客
09-24 246
spring整合mybatis 1.添加相关依赖 注：spring 5.0.1.RELEASE有冲突 1.1 添加spring相关依赖(5.0.2.RELEASE) spring-core spring-beans spring-context spring-orm spring-tx spring-aspects spring-web 1.2 添加mybatis相关依赖 mybatis核心：my...
mybatis与spring集成
m0_67476502的博客
03-28 585
1，添加依赖 2.创建spring.xml配置文件applicationContext，第四步相当于mybatis.cfg.xml 3，在pom.xml引入生成插件 4，导入generatorConfig.xml外部配置文件 5，配置生成插件 6，注解式开发 @Repository：将Mapper类声明为Bean @Service：通常作用在业务层 @Controller：通常作用在控制层，将在Sprin...
spring源码剖析（八）spring整合mybatis原理
热门推荐
Fighter168的专栏
05-21 2万+
MyBatis相信很多人都会使用，但是当MyBatis整合到了spring中，我们发现在Spring中使用更加方便了。既然那么方便，Spring到底为我们做了哪些工作呢，它如何将MyBatis整合到Spring中的呢，Spring在整合MyBatis时候做了哪些封装，以及做了哪些拓展，又是怎么实现这些封装以及拓展的，让我们来打开这一部分的源代码，一探究竟。
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
**Spring整合Mybatis原理分析** 在Java Web开发中，Spring框架以其强大的依赖注入和面向切面编程能力，成为了事实上的核心框架。Mybatis则是一个轻量级的持久层框架，它简化了数据库操作，提供了直观的SQL映射。将...
mybatis-spring-1.3.1.jar下载
05-24
下面将详细介绍MyBatis-Spring的主要功能、工作原理以及如何与MyBatis-3.4.4等版本配合使用。 MyBatis-Spring的主要功能： 1. **自动扫描与配置**：MyBatis-Spring能够自动扫描项目中的Mapper接口，并根据这些接口...
深入浅出重构Mybatis与Spring集成的SqlSessionFactoryBean（上）
09-01
总之，重构Mybatis与Spring集成的SqlSessionFactoryBean是一个技术挑战，需要深入理解两者的工作原理，同时也为我们提供了优化和扩展框架的机会。通过这种方式，我们可以使系统更加健壮，更适应业务需求的变化。在下...
【Spring】总结Spring整合Mybatis的底层原理实现步骤
12-21
（鲁班学院公开课笔记） Dao：数据访问层，提供让Service层调用的接口，更大的时候，Dao层可以是一个项目。 sqlSession.getMapper();使用的是JDK的动态代理 使用时 自定注入的条件：要被Spring管理。被Spring管理的对象叫做Bean @Component注解：表示将生成一个Bean 对象和Bean的区别： 1、Bean就是一个Java对象，是Spring帮我们New出来的对象。 2、从Spring容器中拿到的对象，会给对象里面的包含@AutoWired注解的属性进行自动注入赋值。而手动new出来的对象不会自动注入赋值。 Spring容器中的Bean
mybatis-4 mybatis与spring结合使用及原理解析
08-26
总的来说，MyBatis 与 Spring 的集成使得开发者可以更加专注于业务逻辑，而无需过多关注底层数据库操作和事务管理。这种集成方式提高了代码的可维护性和可测试性，是企业级应用开发中常用的技术组合。
Mybatis整合Spring核心原理
sermonlizhi的博客
11-27 1822
一、Mybatis集成Spring原理 Mybatis是一个单独的半ORM框架，可以与Spring集成使用，也可以单独使用，单独使用代码如下: 加载mybatis.xml的配置文件，然后解析配置文件，创建一个DefaultSqlSessionFactory的工厂对象，通过openSession()打开一个数据库连接的会话，通过getMapper()方法可以为对应的Mapper接口生成一个MapperProxy的代理对象，然后直接调用这个Mybatis的代理对象，就可以执行其中定义的SQL方法 InputSt
MyBatis+Spring基于接口编程的原理分析
死脑袋瓜的专栏
11-07 2620
对于整合Spring及Mybatis不作详细介绍，可以参考： MyBatis 3 User Guide Simplified Chinese.pdf，贴出我的主要代码如下：  UserMapper Interface:  Java代码   package org.denger.mapper;      import org.apache.ibatis.annota
Spring 整合 Mybatis 原理
SuZhan0711
06-21 1661
在 Mybatis 中，我们可以使用一个接口去定义要执行 sql，简化代码如下：定义一个接口，@Select 表示要执行查询 sql 语句。 以下为执行 sql 代码： Mybatis的目的是：使得程序员能够以调用方法的方式执行某个指定的 sql，将执行 sql 的底层逻辑进行了封装。当调用 SqlSession 的 getMapper 方法时，会对传入的接口生成一个代理对象，而程序要真正用到的就是这个代理对象，在调用代理对象的方法时，Mybatis 会取出该方法所对应的 sql 语句，然后利用JDBC 去
MyBatis整合Spring原理分析
imherer的博客
05-19 377
目录MyBatis整合Spring原理分析MapperScan的秘密简单总结 假如不结合Spring框架，我们使用MyBatis时的一个典型使用方式如下： public class UserDaoTest { private SqlSessionFactory sqlSessionFactory; @Before public void setUp() throws Exception{ ClassPathResource resource = new ...
mybatis 原理_Mybatis和Spring集成整合原理详情
weixin_39957805的博客
11-26 123
Mybatis和Spring集成原理前面的系列文章都是单独讲解MyBatis，并未将其和Spring整合起来，看看整合的原理。在了解之前我们大概梳理一下流程:首先MyBatis的核心组件有：SqlSessionFactory和Java接口代理对象，前者用于创建SqlSession，后者是接口的代理对象实现接口访问数据库。本文会按照代码，和基本的思路分析Spring整合MyBatis，如果直接需要源...
MyBatis-Spring集成：Spring与MyBatis无缝整合
MyBatis-Spring是一个强大的框架集成解决方案，专为将MyBatis（一个流行的对象关系映射框架）无缝整合到Spring（一个广泛使用的依赖注入和企业级应用框架）环境中设计。它旨在简化开发过程，减少代码量，并提供事务...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值