[{"type":"Heading1","children":[{"text":"目录"}],"slateId":"b80_ZHnjIhoJ1uMSY8DpR"},{"type":"Paragraph","children":[{"text":"一、（背景）SqlSession、SqlSessionFactory与SqlSessionTemplate的关系"}],"slateId":"JG9iBSG4yq0KRwhkQ-itm"},{"type":"Paragraph","slateId":"VKu4_pmIcCk_GRfK_K6Xc","children":[{"text":" 1. 核心关系定义"}]},{"type":"Paragraph","slateId":"QXORktId_YVM04zsqrqyp","children":[{"text":" A. SqlSessionTemplate (Spring 整合层)"}]},{"type":"Paragraph","slateId":"LDOAAx9v-PKKeBooYNefv","children":[{"text":" B. SqlSessionFactory (工厂)"}]},{"type":"Paragraph","slateId":"fz45YIkc6ypRQ2UHFtZ6N","children":[{"text":" C. SqlSession (SqlSession是MyBatis对数据库连接的一个抽象，一个SqlSession对应一个数据库连接)"}]},{"type":"Paragraph","slateId":"QBiHKoG_EPF7B_toYvf9b","children":[{"text":" 2. 工作原理：它是如何“代理”的？"}]},{"type":"Paragraph","slateId":"Juc0_49PbCN7ASkYa2PZD","children":[{"text":" 场景一：初始化阶段 (Spring 启动时)"}]},{"type":"Paragraph","slateId":"t0UnrW3rc4CjaANs59QJG","children":[{"text":" 场景二：运行阶段 (用户请求到来)"}]},{"type":"Paragraph","slateId":"RjshITDwylFvJCCcTHAp9","children":[{"text":"二、相关组件的装配与注册"}]},{"type":"Paragraph","slateId":"PNb-s7RUROG-Q3WXVFx4M","children":[{"text":" 1. Spring-MyBatis的自动装配（MybatisAutoConfiguration.class）："}]},{"type":"Paragraph","slateId":"MdiICpP6AnS708b9-kNEV","children":[{"text":" 2.Mybatis如何扫描指定目录下XML，并生成 MappedStatement"}]},{"type":"Paragraph","slateId":"jBId3zF0KCfY4z5oP1mzs","children":[{"text":" 3. MapperStatement被调用时如何组装成DB可以执行的sql"}]},{"type":"Paragraph","slateId":"HOModSZsNpsYt9wsgE6FG","children":[{"text":" 1) MapperStatement的结构:"}]},{"type":"Paragraph","slateId":"J2jPEv8oGZqJOwhH4d42Z","children":[{"text":" 2) MapperStatement如何转化为可执行的sql"}]},{"type":"Paragraph","slateId":"i0bVWaboHN__d-aQS8t1z","children":[{"text":" 4. @MapperScan的原理："}]},{"type":"Paragraph","slateId":"x-Iden5SIpbVxPB0GRICL","children":[{"text":" 5.补充： BFPP与 ImportBeanDefinitionRegistrar的区别"}]},{"type":"Paragraph","slateId":"rNxd4WsF7Y5vJ9q4Gur8q","children":[{"text":"三、如何生成mapper代理实例"}]},{"type":"Paragraph","slateId":"vdF1CshZQYsdKZ72UNazo","children":[{"text":" 1. MapperScannerConfigurer从BeanDefinition实例化为Bean"}]},{"type":"Paragraph","slateId":"BOXwv90vzA02kZsbpwgVF","children":[{"text":" 2. 重点：MapperScannerConfigurer是如何扫描并注册BD："}]},{"type":"Paragraph","slateId":"6JGnXMifTIwKDm6LvFDGj","children":[{"text":" 1.BFPP的实现方法"}]},{"type":"Paragraph","slateId":"bUSlVFV0nWfIrGDGFHoSd","children":[{"text":" 2.ClassPathMapperScanner的扫描+改写BD的逻辑"}]},{"type":"Paragraph","slateId":"hT4XHCPuQr_BWvYp5Q_Bo","children":[{"text":" 3. 重点：（userMapper如何实例化）MapperFactoryBean从BD实例化为Bean"}]},{"type":"Paragraph","slateId":"_2v2mamxffl60V6lz5bmU","children":[{"text":" 3.1 检查成员MapperFactoryBean的变量、向Mybatis注册Mapper"}]},{"type":"Paragraph","slateId":"gjiMTtOQjZO-dTSMPGc-v","children":[{"text":" 3.2 生成代理逻辑"}]},{"type":"Paragraph","slateId":"awtun-qL66VEUSZNpOgtC","children":[{"text":" 4. MapperProxy代理的invoke()方法逻辑（当业务调用Mapper时，sql如何执行）："}]},{"type":"Paragraph","slateId":"i3V3S7xDZRtEaDCrXeKjc","children":[{"text":"四、（补充）SqlSessionTemplate如何执行一个sql"}]},{"type":"Paragraph","slateId":"naMpRItI2jSas_fjktaAU","children":[{"text":" 1. SqlSessionTemplate是单例"}]},{"type":"Paragraph","slateId":"wii4XVOx5YHMEVSBkDYp5","children":[{"text":" 2.空壳代理 SqlSessionProxy获取SqlSession"}]},{"type":"Paragraph","slateId":"0sIhfFk8hd_foemMqBn_h","children":[{"text":" 3. 为什么要设计成“空壳代理”？"}]},{"type":"Paragraph","slateId":"g7ch_Wj9jSckxOzLIN42h","children":[{"text":" 4. getSqlSession与closeSqlSession的运行原理"}]},{"type":"Paragraph","slateId":"ZGpL4UnE_ZuTWntH6Ko_o","children":[{"text":" 5. DefaultSqlSession如何执行"}]},{"type":"Paragraph","slateId":"_hBqIXp9AUMEshrpBp-k7","children":[{"text":"五、缓存（mybatis作为ORM层的缓存功能）"}]},{"type":"Paragraph","slateId":"RolNMq0cRTCxipShnbqFZ","children":[{"text":" 1. 一级缓存：SqlSession级别"}]},{"type":"Paragraph","slateId":"8xef-rLla9TiWczT1nkum","children":[{"text":" 2. 二级缓存：mapper级别（mapper级别）"}]},{"type":"Paragraph","slateId":"HKzgEGKZQi3rNEOA5s2ih","children":[{"text":" 3. 三级缓存：mybatis-redis库 + 外置redis"}]},{"type":"Heading1","children":[{"text":"一、（背景）SqlSession、SqlSessionFactory与SqlSessionTemplate的关系"}],"slateId":"r82PWJOnsVIBHoyP-8Uiu"},{"type":"Paragraph","children":[{"text":"SqlSessionTemplate 是 SqlSession 接口的一个"},{"text":"实现类","bold":true},{"text":"，但它不仅仅是简单的实现，它还充当了 MyBatis 原生 API 和 Spring 事务管理、异常体系之间的"},{"text":"适配器（Adapter）","bold":true},{"text":"。"}],"slateId":"wGI6J8NDEhVTlF38OxtYl"},{"type":"Heading2","children":[{"text":"1. 核心关系定义"}],"slateId":"qYdKcFSVF_sKG0ow6vFho"},{"type":"Paragraph","children":[{"text":"spring容器 --管理--> SqlSessionTemplate --持有--> SqlSessionFactory --生产--> SqlSession"}],"slateId":"57-r2K-vvvh3LCAoSN8fH"},{"type":"Heading3","slateId":"ZOgTOw31kZh4CNOYhtX6y","children":[{"text":"A. SqlSessionTemplate (Spring 整合层)"}]},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"来源","bold":true},{"text":"：MyBatis-Spring 整合库 (mybatis-spring.jar)"}],"slateId":"HbeiDDalncEiZUHAx8yLe"}],"slateId":"xy5KAZz_Gs3hFamnzr7PK"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"_JPCgwiUuFRR7m-qpu6G8","children":[{"text":"角色","bold":true},{"text":"：实现了 SqlSession 接口。它是 Spring 管理下的 Bean，所有mapper的sql调用最终都会落到调用 SqlSessionTemplate的方法。它内部持有一个 SqlSessionFactory 引用。当你调用它的方法时，它利用内部的工厂去获取 SqlSession（从当前事务上下文复用，或新建），执行操作，并处理异常和关闭资源。"}]}],"slateId":"gc2EXsNgAu6EU9ipg19nd"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"8t82y_cPTIn9vnG5VmCeo","children":[{"text":"生命周期","bold":true},{"text":"："},{"text":"线程安全","bold":true},{"text":"。由 Spring 容器管理，开发者无需（也不能）手动关闭。它会自动参与 Spring 的事务同步。"}]}],"slateId":"-jMP_0tWlamKg3G1NOweO"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"F9wysuzio7iB4rbOgvZej","children":[{"text":"事务管理","bold":true},{"text":"：完全交给 Spring 的 PlatformTransactionManager处理。"}]}],"slateId":"3K2LKz0Av2q_DlW4PDkXh"},{"type":"Heading3","children":[{"text":"B. SqlSessionFactory (工厂)"}],"slateId":"UtkCqZ3pElc9hbk0O4Z2u"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"Djp5VZ7L-63qk2wXTKQwF","children":[{"text":"来源","bold":true},{"text":"：MyBatis 核心库 (mybatis.jar)"}]},{"type":"ListItem","slateId":"9R0id2wOjSL4ZyPBnejFh","children":[{"text":"职责","bold":true},{"text":"：它是创建 SqlSession的工厂类。它读取 MyBatis 配置文件（如 mybatis-config.xml）、映射文件（Mapper XML）以及数据源（DataSource），完成初始化后，用于生产 SqlSession实例。"}]}],"slateId":"HKaJymfo5HJzHMaGxW-eU"},{"type":"BulletedList","slateId":"ivS6vG2bsZg6MeqA280TO","children":[{"type":"ListItem","slateId":"Nt2UIOYEt-LBJr_5fMAkn","children":[{"text":"特性","bold":true},{"text":"："},{"text":"线程安全。","bold":true},{"text":"在 Spring 应用中，通常将其配置为一个单例 Bean，整个应用生命周期中只需要一个实例。"}]}]},{"type":"Heading3","children":[{"text":"C. SqlSession (SqlSession是MyBatis对数据库连接的一个抽象，一个SqlSession对应一个数据库连接)"}],"slateId":"cB0YWQRKnbrbe5ouputDJ"},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"来源","bold":true},{"text":"：MyBatis 核心库 (mybatis.jar)。由 SqlSessionFactory 生产 (factory.openSession())。"}],"slateId":"QYwkC2w3H2iWlutU4Epg1"}],"slateId":"1bIOBu7nUNkPFnX5KtmuV"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"MlhLtbVyzvRxyt2IvDfCv","children":[{"text":"角色","bold":true},{"text":"：MyBatis 工作的顶层接口，负责执行 SQL、获取 Mapper、管理事务（提交/回滚）和关闭连接。"}]}],"slateId":"biffQ6m3EY1dIuGNLqyWg"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"61VVO1LEkghqpQ3aDi0b9","children":[{"text":"生命周期","bold":true},{"text":"："},{"text":"非线程安全。","bold":true},{"text":"通常由开发者手动创建（通过 SqlSessionFactory.openSession()），使用后必须手动调用 close()，否则会导致数据库连接泄露。每个线程（或每次请求）必须拥有自己独立的 SqlSession 实例，用完后必须关闭。"}]}],"slateId":"jhmX4Y3MOUmKzVkcLqUIU"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"uOYAhlqcMvxh_VpP1-ro8","children":[{"text":"事务管理","bold":true},{"text":"：需要手动调用 commit()或 rollback()。"}]}],"slateId":"E1rRG6CIeLtVPZQwsu7b9"},{"type":"Heading2","slateId":"nWs2NtCllCbx5dztPfy59","children":[{"text":"2. 工作原理：它是如何“代理”的？"}]},{"type":"Heading3","children":[{"text":"场景一：初始化阶段 (Spring 启动时)"}],"slateId":"u4nrajwOOEk39JwHNzLET"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"NtkclLkpGnIEBPe13xVEo","children":[{"text":"Spring 容器启动，创建 SqlSessionFactory Bean（配置了数据源、Mapper 位置等）。"}]}],"slateId":"GoZWYmqMHi_nKx6kzW27c"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"OXd-lgPktgq8sRcHhez6D","children":[{"text":"Spring 容器创建 SqlSessionTemplate Bean。"}]}],"slateId":"n7i6chk5_CTRTmLDlgOjf"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"KqBlCaG-PfdL-Sy6h4uPe","children":[{"text":"关键连接：Spring 将 SqlSessionFactory"},{"text":"注入","bold":true},{"text":" 到 SqlSessionTemplate 中。"}]}],"slateId":"IYhwg71y4VzuT35zRnH5Y"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"zgZAsoRi-9GjkIKXgQzjV","children":[{"text":"此时，SqlSessionTemplate手里拿到了“工厂”，但还没有创建任何 SqlSession"}]}],"slateId":"eAEr09J-e9ve94IT_qsVb"},{"type":"Heading3","children":[{"text":"场景二：运行阶段 (用户请求到来)"}],"slateId":"qQG2Mv_j1bjE3W793cXJu"},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"ZReqr-abWFTbrQ_beTP68","children":[{"text":"请求","bold":true},{"text":"进入：SqlSessionTemplate接收到方法调用。"}]},{"type":"ListItem","slateId":"azd5Z2e0mTRxWtYo1yXE7","children":[{"text":"获取 Session 策略：","bold":true}]},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"2LNY8KVNQ7Inyj6t_eOO3","children":[{"text":"SqlSessionTemplate 询问 Spring 的事务管理器：“当前线程有正在运行的事务吗？”"}]},{"type":"ListItem","slateId":"SD0TXSNget6qMOZ2P_l27","children":[{"text":"情况 A（有事务）","bold":true},{"text":"：事务管理器返回当前线程绑定的 SqlSession。SqlSessionTemplate直接使用它。"},{"text":"（此时没有调用工厂创建新对象）","bold":true}]},{"type":"ListItem","slateId":"EP5ztysJUdU9W2k3ZE-m3","children":[{"text":"情况 B（无事务）","bold":true},{"text":"：SqlSessionTemplate调用内部持有的 SqlSessionFactory.openSession() 方法，创建一个新的 SqlSession。"}]},{"type":"ListItem","slateId":"Qxxo3u-Am6jVRx3cRptqo","children":[{"text":"执行 SQL","bold":true},{"text":"：使用获取到的 SqlSession执行具体的数据库操作。"}]},{"type":"ListItem","slateId":"9CEcKZXVrJk1T6ot9lSTl","children":[{"text":"清理资源","bold":true},{"text":"："}]},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"MsQ6_CG1UWJ2R24ZIhzS_","children":[{"text":"如果是情况 A：SqlSessionTemplate什么都不做，等待事务管理器在事务结束时统一提交/回滚并关闭。"}]},{"type":"ListItem","slateId":"8J2aa794a2nSA0oZpNsWf","children":[{"text":"如果是情况 B：SqlSessionTemplate 在方法执行完毕后，立即调用 sqlSession.close() 关闭刚才创建的临时 Session。"}]}],"slateId":"TFDJtI7b6gohSXf7wrHhl"}],"slateId":"vJ9WEQlA2gmRKN-Vxsv7M"}],"slateId":"j6E-qwFvIgqrDaPRX0WUR"},{"type":"Heading1","children":[{"text":"二、相关组件的装配与注册"}],"slateId":"03cDqeotCyd7fjs5SorOZ"},{"type":"Heading2","children":[{"text":"1. Spring-MyBatis的自动装配（MybatisAutoConfiguration.class）："}],"slateId":"X862p172BtUTDA_ip8RG2"},{"type":"Paragraph","children":[{"text":"自动装配依赖MybatisAutoConfiguration, 其被调用时主要完成3个行为："}],"slateId":"0aFXzMMaHQzgJkSE2-Gm6"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@org.springframework.context.annotation.Configuration(proxyBeanMethods = false)\n@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })\n@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class }) // 保证DataSource先被注入\npublic class MybatisAutoConfiguration implements InitializingBean {\n\n// ================= 第一步：装配 SqlSessionFactory =================\n// 这一步很重要，XML 定义到 SqlStatement的解析也在这里处理\n @Bean\n @ConditionalOnMissingBean\n public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {\n // 1. 创建工厂构建器SqlSessionFactoryBean\n SqlSessionFactoryBean factory = new SqlSessionFactoryBean();\n // 2.注入核心依赖：DataSource\n factory.setDataSource(dataSource);\n // 3. 获取Mybatis.jar中的org.apache.ibatis.session.Configuration实例，没有则new 一个\n applyConfiguration(factory);\n \n // 4. 从application.yml文件获取用户配置的 mybatis.mapper-locations 值(指明sql声明文件的位置，即所有*Mapper.xml文件)\n Resource[] mapperLocations = this.properties.resolveMapperLocations();\n // 5. 设置到mapperLocations到SqlSessionFactoryBean\n if (!ObjectUtils.isEmpty(mapperLocations)) {\n factory.setMapperLocations(mapperLocations);\n }\n \n // 6. 其他配置设置：设置各种SqlSessionFactory相关配置(config location, type aliases 等)\n ........\n // 7. 如果有自定义的 ConfigurationCustomizer，应用它们\n applySqlSessionFactoryBeanCustomizers(factory);\n // 8. 构建并返回 SqlSessionFactory 实例\n return factory.getObject();\n }\n\n // ================= 第二步：装配 SqlSessionTemplate =================\n @Bean // 入参为SqlSessionFactory，说明注入该bean的前置条件为必须存在 SqlSessionFactory (通常是上面创建的)\n @ConditionalOnMissingBean \n public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {\n ExecutorType executorType = this.properties.getExecutorType();\n if (executorType != null) {\n // 如果配置了 (如 BATCH)，则使用带 ExecutorType 的构造函数\n return new SqlSessionTemplate(sqlSessionFactory, executorType);\n } else {\n return new SqlSessionTemplate(sqlSessionFactory);\n }\n }\n // ================= 第三步：使用傀儡配置类，装配一个BFPP，即 AutoConfiguredMapperScannerRegistrar =================\n @org.springframework.context.annotation.Configuration(proxyBeanMethods = false)\n @Import(AutoConfiguredMapperScannerRegistrar.class)\n // 仅在找不到Mapper扫描注册器(即用户定义的MapperScannerConfigurer，或用户没有注释@MapperScan(该注释实质上是根据注释入参，去注册了个MapperScannerConfigurer)后，才会执行该类的Import注解\n @ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })\n public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {\n .......\n }\n }\n\n // ================= 傀儡配置类：注册默认的 MapperScannerConfigurer 的BeanDefinition =================\n public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, EnvironmentAware, ImportBeanDefinitionRegistrar {\n private BeanFactory beanFactory;\n private Environment environment;\n\n @Override\n public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {\n\n if (!AutoConfigurationPackages.has(this.beanFactory)) {\n logger.debug(\"Could not determine auto-configuration package, automatic mapper scanning disabled.\");\n return;\n }\n\n List packages = AutoConfigurationPackages.get(this.beanFactory);\n if (logger.isDebugEnabled()) {\n packages.forEach(pkg -> logger.debug(\"Using auto-configuration base package '{}'\", pkg));\n }\n\n BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);\n builder.addPropertyValue(\"processPropertyPlaceHolders\", true);\n builder.addPropertyValue(\"annotationClass\", Mapper.class);\n builder.addPropertyValue(\"basePackage\", StringUtils.collectionToCommaDelimitedString(packages));\n BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);\n Set propertyNames = Stream.of(beanWrapper.getPropertyDescriptors()).map(PropertyDescriptor::getName)\n .collect(Collectors.toSet());\n if (propertyNames.contains(\"lazyInitialization\")) {\n // Need to mybatis-spring 2.0.2+\n builder.addPropertyValue(\"lazyInitialization\", \"${mybatis.lazy-initialization:false}\");\n }\n if (propertyNames.contains(\"defaultScope\")) {\n // Need to mybatis-spring 2.0.6+\n builder.addPropertyValue(\"defaultScope\", \"${mybatis.mapper-default-scope:}\");\n }\n\n // for spring-native\n boolean injectSqlSession = environment.getProperty(\"mybatis.inject-sql-session-on-mapper-scan\", Boolean.class,\n Boolean.TRUE);\n if (injectSqlSession && this.beanFactory instanceof ListableBeanFactory) {\n ListableBeanFactory listableBeanFactory = (ListableBeanFactory) this.beanFactory;\n Optional sqlSessionTemplateBeanName = Optional\n .ofNullable(getBeanNameForType(SqlSessionTemplate.class, listableBeanFactory));\n Optional sqlSessionFactoryBeanName = Optional\n .ofNullable(getBeanNameForType(SqlSessionFactory.class, listableBeanFactory));\n if (sqlSessionTemplateBeanName.isPresent() || !sqlSessionFactoryBeanName.isPresent()) {\n builder.addPropertyValue(\"sqlSessionTemplateBeanName\",\n sqlSessionTemplateBeanName.orElse(\"sqlSessionTemplate\"));\n } else {\n builder.addPropertyValue(\"sqlSessionFactoryBeanName\", sqlSessionFactoryBeanName.get());\n }\n }\n builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);\n\n registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());\n }\n }\n}"}],"slateId":"axThlxSdfw00XbZHpLe5z"}],"slateId":"z1VQlWbZkhozpq4G650IH"},{"type":"Paragraph","children":[{"text":" 1. 根据DateSource来构建SqlSessionFactory，并注入IOC容器："}],"slateId":"o-oHN_TO9lizcdgYbzp4L"},{"type":"Paragraph","slateId":"KKIVMl76ZQVb7ZetCDQ7o","children":[{"text":" 这里使用SqlSessionFactoryBean来创建SqlSessionFactory（看似多此一举），这是因为手动创建SqlSessionFactory实例无法集成类似于Spring生命周期之类的扩展"}]},{"type":"Paragraph","slateId":"Zgx0SKDIEOS5aCkwY2jDs","children":[{"text":" 而SqlSessionFactoryBean实现了 FactoryBean、InitializingBean、ApplicationListener接口，让生成的Bean完美容器Spring设计体系"}]},{"type":"Paragraph","slateId":"F0c51Ln5YrslxtZHkWcXA","children":[{"text":" 2. 根据SqlSessionFactory来构建SqlSessionTemplate，并注入IOC容器，后续每个Mapper代理类实例，都会持有该SqlSessionTemplate的引用"}]},{"type":"Paragraph","slateId":"kNnaFb1Q18aUTv27lQL-A","children":[{"text":" SqlSessionTemplate 是线程安全的 SqlSession 代理"}]},{"type":"Paragraph","slateId":"Vnz0PqPSVAKXDl-HyT4yC","children":[{"text":" 内部使用 ThreadLocal + Spring 事务管理器"}]},{"type":"Paragraph","slateId":"9Tln1IqV2hBjXZbUN5eqM","children":[{"text":" 所有 Mapper 代理最终都使用这个 SqlSessionTemplate来"}]},{"type":"Paragraph","slateId":"hU_CzDDQ0nqa_s52lgZS7","children":[{"text":" 3. 如果没有使用@MapperScan或 @Bean注入用户自定义的 MapperScannerConfigurer.class，则使用一个"},{"text":"傀儡配置类","bold":true},{"text":"注入默认的MapperScannerConfigurer.class的实例（通过MybatisAutoConfiguration类里有个静态内部类 AutoConfiguredMapperScannerRegistrar.class，其实现了ImportBeanDefinitionRegistrar接口）："}]},{"type":"Paragraph","slateId":"t5sNeZ6YkN90bFxCigp1z","children":[{"text":" 4. 自动装配注入的MapperScannerConfigurer.class（默认的）："}]},{"type":"Paragraph","slateId":"s8aWHA2i00U9ts4TB5p5k","children":[{"text":" 功能：扫描主包路径下的所有类，最终筛选带有@Mapper注解的接口；"}]},{"type":"Paragraph","slateId":"3qtqqSEEoBAAbUXlgglfv","children":[{"text":" 结论：如果不使用@MapperScan的话，就需要给"},{"text":"每一个Mapper接口带上@Mapper注解","bold":true}]},{"type":"Heading2","children":[{"text":"2.Mybatis如何扫描指定目录下XML，并生成 MappedStatement"}],"slateId":"3nv1UN6uNSPzRC87qFwk6"},{"type":"Paragraph","children":[{"text":"Mybatis扫描指定目录下XML文件，并生成SQLStatement的逻辑发生在MybatisAutoConfiguration向IOC容器注入SqlSessionFactory的过程中："}],"slateId":"2pBPUTzwrmPQqOk6vO3T6"},{"type":"Paragraph","slateId":"OpTzlaOKzpaeTERUQwuq0","children":[{"text":"在第二.1 节的第一步（装配 SqlSessionFactory ）中，通过SqlSessionFactoryBean.getObject( )来获取一个SqlSessionFactory实现类"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// SqlSessionFactoryBean.class\npublic class SqlSessionFactoryBean\n implements FactoryBean, InitializingBean, ApplicationListener {\n \n @Override\n public SqlSessionFactory getObject() throws Exception {\n if (this.sqlSessionFactory == null) {\n afterPropertiesSet();\n }\n return this.sqlSessionFactory;\n }\n \n @Override\n public void afterPropertiesSet() throws Exception {\n notNull(dataSource, \"Property 'dataSource' is required\");\n notNull(sqlSessionFactoryBuilder, \"Property 'sqlSessionFactoryBuilder' is required\");\n \n this.sqlSessionFactory = buildSqlSessionFactory();\n }\n \n \n protected SqlSessionFactory buildSqlSessionFactory() throws Exception {\n // 定义最终要使用的 MyBatis Configuration 对象\n final Configuration targetConfiguration;\n\n XMLConfigBuilder xmlConfigBuilder = null;\n \n if (this.configuration != null) {\n targetConfiguration = this.configuration;\n // 将用户在yml中配置的 mybatis.configurationProperties注入Configuration中\n if (targetConfiguration.getVariables() == null) {\n targetConfiguration.setVariables(this.configurationProperties);\n } else if (this.configurationProperties != null) {\n targetConfiguration.getVariables().putAll(this.configurationProperties);\n }\n } else if (this.configLocation != null) {\n // 非自动装配场景：使用XMLConfigBuilder去解析this.configLocation指向的xml文件，通常是 mybatis-config.xml\n xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);\n targetConfiguration = xmlConfigBuilder.getConfiguration();\n }\n\n // 使用Optional类包装方法调用：在this.objectFactory不为null时，调用 this.configuration.setObjectFactory() 方法\n // ObjectFactory：控制 MyBatis 如何实例化结果对象（默认用反射 new，可自定义）。\n Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);\n\n // 注册脚本语言驱动（通常是XML）、注册插件 (Plugins / Interceptors)、注册类型别名 (Type Aliases)\n ....\n \n \n // 如果配置了 databaseIdProvider（根据 DataSource 的元数据判断是 MySQL 还是 Oracle，获取数据库标识符（如 \"mysql\"）设置到配置中。\n // 作用：允许你在 XML 中写 , , 等标签。将这些标签解析成 MappedStatement 对象，并存入 targetConfiguration 的内存中\n \n xmlMapperBuilder.parse();\n } \n }\n } \n \n // 此时 targetConfiguration 已经是一个完全体：有了数据源和事务管理器\\有了所有别名、插件、类型处理器\\有了所有解析好的 SQL 语句。\n // 调用 sqlSessionFactoryBuilder.build()，基于这个配置创建最终的 SqlSessionFactory 实例。\n return this.sqlSessionFactoryBuilder.build(targetConfiguration);\n }\n}"}],"slateId":"OOrsad3WIWQJlAwhtyFIo"}],"slateId":"BAcabu1LUGp2QkJwsblq2"},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"重点1："},{"text":"绑定 Spring 事务和数据源","bold":true},{"text":"。"}],"slateId":"m6sLU-9-_6Aqs6GTCZyrP"}],"slateId":"Aj9uckLMsPfLzY6viTKLt"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"2fq8uCnFXtmm8d1Rvkq7u","children":[{"text":"创建 MyBatis 的 Environment 对象。"}]}],"slateId":"O2J6WfAUDC1pDObhXfBJ4"}],"slateId":"AAc_-dAvUCghcEDJQHtIW"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"BhrCahlu1gOFH3J5Nt-ea","children":[{"text":"参数 1","bold":true},{"text":"：环境 ID（通常为开发、测试、生产标识）。"}]}],"slateId":"KWpol4qJ1XVwEHLK6w_GI"}],"slateId":"zLymwtidiICQxSPPI5bmB"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"DEKnTbXp_8vEwCeHFjFu6","children":[{"text":"参数 2","bold":true},{"text":"："},{"text":"事务工厂","bold":true},{"text":"。"}]}],"slateId":"b9tc9ZNAR-7VujfDqzS06"}],"slateId":"LfAHdoKumBnq1xWfvXvep"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"uvSAl9EXuxn0fx3a4wL28","children":[{"text":"如果没有显式配，默认使用 SpringManagedTransactionFactory。"}]}],"slateId":"V6dZKZT8PE6bjYzyHJdVO"}],"slateId":"BZReNHL-LVF5qfXv97UQS"}],"slateId":"wQoO2fFQ5TJ7j4DvWJf_U"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"dcl29tIXvYWv7JqOE6RO-","children":[{"text":"核心意义","bold":true},{"text":"：这告诉 MyBatis：“不要自己管理事务（不要自动 commit/rollback），去问 Spring 拿当前事务”。这是 Spring 声明式事务（@Transactional）能控制 MyBatis 的关键。"}]}],"slateId":"zslcrpD-V8IFNCjN0zHX6"}],"slateId":"Q88otlExfWCuO5PwFK9Yb"}],"slateId":"e_AdjTCpLSPi4QWWuFjm7"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"z-Y8LNcVbIXLvnMoKCEPj","children":[{"text":"参数 3：数据源。直接使用 Spring 注入的 DataSource（连接池）。"}]}],"slateId":"aEr58caFEJgTb8Os_YuhG"}],"slateId":"5oP4RPS1goyxx6PE7zWqc"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// XmlMapperBuilder.class源码\n// 解析单个mapper文件，其中每个Statement调用XMLStatementBuilder去解析\npublic class XMLMapperBuilder extends BaseBuilder {\n // 构造函数会为 XMLMapperBuilder实例提供 configuration的引用\n protected final Configuration configuration;\n\n public void parse() {\n // 防重入1，避免多次解析\n if (!configuration.isResourceLoaded(resource)) {\n // 重点：从xml根节点开始解析\n configurationElement(parser.evalNode(\"/mapper\"));\n // 防重入2，避免多次解析\n configuration.addLoadedResource(resource);\n // 重点：绑定命名空间， \n bindMapperForNamespace();\n }\n .........\n // 延迟绑定：xml每个标签都解析完了（防止节点间的依赖关系不完整），开始绑定MapperStatement\n configuration.parsePendingStatements(false);\n }\n \n // 这里开始解析标签下各子节点、以及各标签包含的属性Attribute\n private void configurationElement(XNode context) {\n try {\n String namespace = context.getStringAttribute(\"namespace\");\n if (namespace == null || namespace.isEmpty()) {\n throw new BuilderException(\"Mapper's namespace cannot be empty\");\n }\n builderAssistant.setCurrentNamespace(namespace);\n cacheRefElement(context.evalNode(\"cache-ref\"));\n cacheElement(context.evalNode(\"cache\"));\n parameterMapElement(context.evalNodes(\"/mapper/parameterMap\"));\n resultMapElements(context.evalNodes(\"/mapper/resultMap\"));\n sqlElement(context.evalNodes(\"/mapper/sql\"));\n // ！！！重点：这里开始生产MapperStatement，筛选包含select|insert|update|delete的xml节点\n buildStatementFromContext(context.evalNodes(\"select|insert|update|delete\"));\n } \n }\n \n private void buildStatementFromContext(List list) {\n if (configuration.getDatabaseId() != null) {\n //用户指定了 databaseID，则筛选带有指定标签的节点\n buildStatementFromContext(list, configuration.getDatabaseId());\n }\n buildStatementFromContext(list, null);\n }\n\n private void buildStatementFromContext(List list, String requiredDatabaseId) {\n for (XNode context : list) {\n final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context,\n requiredDatabaseId);\n try {\n // 开始生成每个或节点）下的所有子节点。"}]}],"slateId":"PP9WCHl7tic86238K-Ji9"}],"slateId":"dqbEhs3nWXP4XUiy6jARy"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"ipIDZ-bDVX5Hp51h4Dmqj","children":[{"text":"动态 SQL ","bold":true},{"text":"识别：识别 , , , 等标签，将其转换为对应的 SqlNode 对象树（如 IfSqlNode, ForEachSqlNode）。"}]}],"slateId":"JEooO2Xe08aQvzy41CsYd"}],"slateId":"lv9lH5X6q3zU1MFUX-VLs"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"1SbfBeqnQrgIVBXu079tf","children":[{"text":"产出：返回一个 SqlSource 接口的实现类。"}]}],"slateId":"u-HqtZKOtETT-GAlbf0FE"}],"slateId":"aazxhrILG_LCe8AlDUmYi"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"GWueI6g3x0R_12-aq5pX5","children":[{"text":"如果包含动态标签 -> 返回 DynamicSqlSource（运行时每次执行都要重新组装 SQL）。 "}]}],"slateId":"MyodVHioWAIPqG1SMFMiQ"}],"slateId":"FzVLewPvta1pqpxSbwGkW"}],"slateId":"Xwg_zM-GhbEltpsC0ekos"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"5Jq-FayKflZnJrTb_YmoL","children":[{"text":"如果全是静态文本 -> 返回 StaticSqlSource或 RawSqlSource（启动时解析一次，运行时无开销）"}]}],"slateId":"JCheZrtSJd4Hz8u1rEe9i"}],"slateId":"M1yoB5SItcFdSf2CTF1Qy"}],"slateId":"pt6h0ktCfhjUrSqx2ZFYH"},{"type":"Heading2","children":[{"text":"3. MapperStatement被调用时如何组装成DB可以执行的sql"}],"slateId":"TaUrn5pUhX1-Q2alLJfgu"},{"type":"Heading3","children":[{"text":"1) MapperStatement的结构:"}],"slateId":"h6VTSH6O7e8_PyZIZZIJy"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public final class MappedStatement {\n private Configuration configuration; // mybatis上下文\n private String id; // 唯一标识，通常是 namespace + \".\" + method（如 com.example.UserMapper.selectById）。\n private Integer fetchSize; // JDBC 每次获取的行数\n private Integer timeout; // SQL 执行超时时间\n private SqlSource sqlSource; // 核心\n private ParameterMap parameterMap; // 定义输入参数的类型以及如何将 Java 对象映射到 SQL 占位符。\n private ResultSetType resultSetType; // 定义查询结果如何映射回 Java 对象（包括复杂的关联查询映射）。\n private List resultMaps;\n private boolean flushCacheRequired; // 是否在执行后刷新缓存\n private boolean useCache; // 是否使用缓存\n private SqlCommandType sqlCommandType; // 标识这是 SELECT、INSERT、UPDATE 还是 DELETE。\n ....................\n}\n// sqlSource 是一个接口主要是实现类是DynamicSqlSource，也就是对应的xml解析出来的动态sql\npublic class DynamicSqlSource implements SqlSource {\n private final Configuration configuration;\n private final SqlNode rootSqlNode;\n}\n// sqlNode实际上是一个对象树\n// 例子：解析如下xml时\n/**\nSELECT * FROM user \nWHERE 1=1\n\n AND name = #{name}\n\n**/\nDynamicSqlSource\n└── rootSqlNode (MixedSqlNode)\n └── contents (List)\n ├── StaticTextSqlNode: \"SELECT * FROM user WHERE 1=1\"\n └── IfSqlNode: (test=\"name != null\")\n └── contents (List)\n └── StaticTextSqlNode: \"AND name = \"\n └── ExpressionSqlNode: \"#{name}\""}],"slateId":"xGb9-Wevh9C8z8f72fyM7"}],"slateId":"H2rnkVBxfdt9spp0zuYoh"},{"type":"Paragraph","children":[{"text":""}],"slateId":"M7ON27pKDOHNTbm-Ax9PV"},{"type":"Heading3","slateId":"QSsef_0JUtEPPlN4J_A0A","children":[{"text":"2) MapperStatement如何转化为可执行的sql"}]},{"type":"Paragraph","children":[{"text":"当当前线程的sqlSession，调用其Executor去执行sql之前，需要把当前MapperStatement对应的sql解析出来（这里不懂的参考第四节）"}],"slateId":"chzMvyIitnTTjJobxZyAr"},{"type":"Paragraph","slateId":"WhyJgIX9TmlvvIY_SYN6n","children":[{"text":"结论","bold":true},{"text":"：实际上MapperStatement（或者说sqlSource）是SqlSession的 Executor在调用"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 1. Executor 执行查询\npublic List query(MappedStatement ms, Object parameter, ...) throws SQLException {\n // 2. 向 MappedStatement 请求 BoundSql，并传入本次的参数\n BoundSql boundSql = ms.getBoundSql(parameter);\n // ... 后续根据 boundSql 创建 Statement 并执行\n}\n\n// 3. MappedStatement 委托给 SqlSource\npublic BoundSql getBoundSql(Object parameterObject) {\n return sqlSource.getBoundSql(parameterObject);\n}\n\npublic class DynamicSqlSource implements SqlSource {\n\n @Override\n public BoundSql getBoundSql(Object parameterObject) {\n // 1. 创建上下文，相当于准备了一个 StringBuilder 和一个参数 Map\n DynamicContext context = new DynamicContext(configuration, parameterObject);\n \n // 2. 执行 SqlNode 树\n // 这里会处理 , , 等标签\n // 结果：SQL 片段被拼接，${} 被替换，但 #{} 依然存在\n rootSqlNode.apply(context);\n \n // 3. 处理 #{} 占位符\n // 这里的 parse 方法会利用正则表达式找到 #{}，将其替换为 ?\n // 同时解析出参数类型，生成 ParameterMapping 对象\n SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);\n Class parameterType = parameterObject == null ? Object.class : parameterObject.getClass();\n \n // 关键点：parse 返回的是 StaticSqlSource，它里面存的 SQL 已经是 \"SELECT ... WHERE id = ?\"\n SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());\n \n // 4. 获取最终的 BoundSql\n // StaticSqlSource.getBoundSql() 会 new 出一个 BoundSql 对象\n BoundSql boundSql = sqlSource.getBoundSql(parameterObject);\n \n // 5. 拷贝动态参数\n // 将 foreach 循环中生成的临时变量（如 __frch_id_0）拷贝到 boundSql 的 additionalParameters 中\n context.getBindings().forEach(boundSql::setAdditionalParameter);\n \n return boundSql;\n }\n}"}],"slateId":"6oPI-fro9KcKkqYTq1Iox"}],"slateId":"WQSU8rmu8wz1q0rD5tC45"},{"type":"Paragraph","children":[{"text":""}],"slateId":"Mo4pSzxAl71Vpy4nHYR7y"},{"type":"Paragraph","slateId":"yo2VymBI5GMnzT8PMC9kE","children":[{"text":"1. **创建上下文**：创建一个 `DynamicContext`（相当于一个临时的 StringBuilder）。"}]},{"type":"Paragraph","slateId":"nact01eB9A5tTMaWs6Uzn","children":[{"text":"2. **遍历树**：调用 `rootSqlNode.apply(context)`。"}]},{"type":"Paragraph","slateId":"zut7JmXjfYP1k9ZQ3H6fG","children":[{"text":"3. **递归拼接**："}]},{"type":"Paragraph","slateId":"W5oRDMqjX3yrZHUNkK4LF","children":[{"text":" * 遇到 `StaticTextSqlNode`：直接把存的字符串追加到 `context` 中。"}]},{"type":"Paragraph","slateId":"HlIQLp4z7q91FLdPme2wl","children":[{"text":" * 遇到 `IfSqlNode`：先判断条件，如果为真，再递归调用子节点的 `apply` 方法。"}]},{"type":"Paragraph","slateId":"vTz6Dqu9j39q66iLGn0GH","children":[{"text":"4. **生成结果**：遍历结束后，`context` 里就有了拼接好的完整 SQL 字符串，然后再处理 `#{}` 占位符，最终生成 `BoundSql`。"}]},{"type":"Paragraph","slateId":"suEvhHFmGnAKqp9mYoKlr","children":[{"text":""}]},{"type":"Heading2","slateId":"S1U-5KDtzWlIu_aLq-Ev9","children":[{"text":"4. @MapperScan的原理："}]},{"type":"Paragraph","children":[{"text":""}],"slateId":"HnOdZ4kAobQ2GliYL44PC"},{"type":"Paragraph","children":[{"text":"1. 本质是注册一个MapperScannerConfigurer.class的BeanDefinition对象；"}],"slateId":"OLcw5umEWvVvEDtF_UKAl"},{"type":"Paragraph","slateId":"KF9V99M4v0_pFUf_eDsZ1","children":[{"text":"2. @MapperScan是由多个注解组合成的注解，其中最重要的是："},{"text":"@Import(MapperScannerRegistrar.class","bold":true},{"text":") ；"}]},{"type":"Paragraph","slateId":"7hUBFKUK2c69YKzX0zGVf","children":[{"text":"3. MapperScannerRegistrar.class是一个实现了ImportBeanDefinitionRegistrar接口的类，其作用是注册一个自定义（通常基于@MapperScan注解中携带的basePackages值）的"},{"text":"MapperScannerConfigurer.class","bold":true}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@Retention(RetentionPolicy.RUNTIME)\n@Target(ElementType.TYPE)\n@Import(MapperScannerRegistrar.class)\n@Repeatable(MapperScans.class)\npublic @interface MapperScan {\n ......\n}\n\n// MapperScannerRegistrar.class是一个实现了ImportBeanDefinitionRegistrar接口的类\n// ========== 注册根据@MapperScan的入参属性配置的MapperScannerConfigurer的BeanDefinition ======================\npublic class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {\n @Override\n public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {\n // 获取@MapperScan的入参属性，如basePackages、sqlSessionFactoryRef\n AnnotationAttributes mapperScanAttrs = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));\n if (mapperScanAttrs != null) {\n registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry, generateBaseBeanName(importingClassMetadata, 0));\n }\n }\n\n void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs, BeanDefinitionRegistry registry, String beanName) {\n // 创建一个MapperScannerConfigurer的BeanDefinition\n BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);\n builder.addPropertyValue(\"processPropertyPlaceHolders\", annoAttrs.getBoolean(\"processPropertyPlaceHolders\"));\n\n Class annotationClass = annoAttrs.getClass(\"annotationClass\");\n if (!Annotation.class.equals(annotationClass)) {\n builder.addPropertyValue(\"annotationClass\", annotationClass);\n }\n\n Class markerInterface = annoAttrs.getClass(\"markerInterface\");\n if (!Class.class.equals(markerInterface)) {\n builder.addPropertyValue(\"markerInterface\", markerInterface);\n }\n\n Class generatorClass = annoAttrs.getClass(\"nameGenerator\");\n if (!BeanNameGenerator.class.equals(generatorClass)) {\n builder.addPropertyValue(\"nameGenerator\", BeanUtils.instantiateClass(generatorClass));\n }\n\n Class mapperFactoryBeanClass = annoAttrs.getClass(\"factoryBean\");\n if (!MapperFactoryBean.class.equals(mapperFactoryBeanClass)) {\n builder.addPropertyValue(\"mapperFactoryBeanClass\", mapperFactoryBeanClass);\n }\n\n // 为 MapperScannerConfigurer 的成员变量sqlSessionTemplateBeanName注入值\n String sqlSessionTemplateRef = annoAttrs.getString(\"sqlSessionTemplateRef\");\n if (StringUtils.hasText(sqlSessionTemplateRef)) {\n builder.addPropertyValue(\"sqlSessionTemplateBeanName\", annoAttrs.getString(\"sqlSessionTemplateRef\"));\n }\n\n String sqlSessionFactoryRef = annoAttrs.getString(\"sqlSessionFactoryRef\");\n if (StringUtils.hasText(sqlSessionFactoryRef)) {\n builder.addPropertyValue(\"sqlSessionFactoryBeanName\", annoAttrs.getString(\"sqlSessionFactoryRef\"));\n }\n\n List basePackages = new ArrayList<>();\n\n basePackages.addAll(Arrays.stream(annoAttrs.getStringArray(\"basePackages\")).filter(StringUtils::hasText)\n .collect(Collectors.toList()));\n\n basePackages.addAll(Arrays.stream(annoAttrs.getClassArray(\"basePackageClasses\")).map(ClassUtils::getPackageName)\n .collect(Collectors.toList()));\n\n if (basePackages.isEmpty()) {\n basePackages.add(getDefaultBasePackage(annoMeta));\n }\n\n String lazyInitialization = annoAttrs.getString(\"lazyInitialization\");\n if (StringUtils.hasText(lazyInitialization)) {\n builder.addPropertyValue(\"lazyInitialization\", lazyInitialization);\n }\n\n String defaultScope = annoAttrs.getString(\"defaultScope\");\n if (!AbstractBeanDefinition.SCOPE_DEFAULT.equals(defaultScope)) {\n builder.addPropertyValue(\"defaultScope\", defaultScope);\n }\n\n builder.addPropertyValue(\"basePackage\", StringUtils.collectionToCommaDelimitedString(basePackages));\n // for spring-native\n builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);\n registry.registerBeanDefinition(beanName, builder.getBeanDefinition());\n }\n}"}],"slateId":"nyo5VQ_jBCjiZmjpnR49V"}],"slateId":"jWGaJmeQq37E_Ox-gse12"},{"type":"Heading2","children":[{"text":"5.补充： BFPP与 ImportBeanDefinitionRegistrar的区别"}],"slateId":"j6ovJJpUP-xmkkHpHrws_"},{"type":"Image","src":"https://pic.leetcode.cn/1778827519-OqHjwe-image.png","children":[{"text":""}],"slateId":"-pGoTMhMmpdTiot-RW520"},{"type":"Paragraph","children":[{"text":""}],"slateId":"jfI7QiSIYxodZiEnJrO2b"},{"type":"Heading1","slateId":"ckcF3aCglqd-I-z9VoCsa","children":[{"text":"三、如何生成mapper代理实例"}]},{"type":"Heading2","children":[{"text":"1. MapperScannerConfigurer从BeanDefinition实例化为Bean"}],"slateId":"cbnHHARvCFq5cncV1Z78t"},{"type":"Paragraph","children":[{"text":"1.上述的 MapperScannerConfigurer 实现了BeanDefinitionRegistryPostProcessor接口，即这是一个BFPP"}],"slateId":"XbSME8KpLeCXNSn0I08Vx"},{"type":"Paragraph","slateId":"kqLSceixNSDALgY8wXjUY","children":[{"text":"2. Spring 容器"},{"text":"优先","bold":true},{"text":"实例化所有实现了 BeanFactoryPostProcessor接口的 Bean。"}]},{"type":"Paragraph","slateId":"HFpzaTE1hzbWuPIj-F8Fh","children":[{"text":"调用构造函数 -> 创建 BFPP 对象实例。"}]},{"type":"Paragraph","slateId":"4cK5wosH1CO8A6_HwCfPl","children":[{"text":"进行依赖注入（如果 BFPP 本身依赖其他 Bean，这里可能会触发级联初始化，但通常 BFPP 不应依赖普通业务 Bean）。"}]},{"type":"Paragraph","slateId":"y7dHicIoeGVGbt0L0MegG","children":[{"text":"3. "},{"text":"详细的过程可以阅读“Spring-Application启动”那篇文章：","bold":true}]},{"type":"Paragraph","slateId":"7weVxzNbLbXbm9eF9fTiq","children":[{"text":" 在SpringApplication.run() -> ApplicationContext.refresh() -> invokeBeanFactoryPostProcessors(...) -> beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));"}]},{"type":"Paragraph","slateId":"0lt87yvaQHMHjVs3nGJEi","children":[{"text":"4. 结论：BFPP在refresh() -> invokeBeanFactoryPostProcessors(...)过程中提前完成Bean的初始化"}]},{"type":"Heading2","children":[{"text":"2. 重点：MapperScannerConfigurer是如何扫描并注册BD："}],"slateId":"H5Wve7ypM-dsPv8qn2HSw"},{"type":"Paragraph","children":[{"text":"MapperScannerConfigurer的核心任务：","bold":true}],"slateId":"GxH4neR-0rGxfEMduUycN"},{"type":"Paragraph","slateId":"DV0bnZYgbfKimccAxMEe3","children":[{"text":" 在 Spring 容器启动的“BeanDefinition 注册阶段”，把"},{"text":"ClassPathMapperScanner","bold":true},{"text":" 扫描到的Mapper 接口转换成 MapperFactoryBean 类型的 BeanDefinition，并注册到容器中。"}]},{"type":"Paragraph","slateId":"fh4LIjOIP-5tMgYP6_mKm","children":[{"text":"类签名：","bold":true}]},{"type":"Paragraph","slateId":"9RWWJ4j5PfFPTAJkwGa0W","children":[{"text":" public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware "}]},{"type":"Paragraph","slateId":"OUZWAEiA2VyIZ3GJESpyo","children":[{"text":"MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口：该接口用于在容器初始化阶段动态修改或注册Bean定义"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {\n // 1.该方法有BeanDefinitionRegistry可以注册/修改BeanDefinition，MapperScannerConfigurer.class正是实现了这个方法\n void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;\n // 2. BeanFactoryPostProcessor接口的方法，只能修改BeanDefinition\n default void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {\n }\n}"}],"slateId":"7hxt-cfUDMV9p6gFrMCUY"}],"slateId":"xiQ11-5pfWLyXBKszfOcJ"},{"type":"Paragraph","children":[{"text":"Spring 会在所有 @Configuration 类解析完、但在普通 Bean 实例化前，调用MapperScannerConfigurer.class的 postProcessBeanDefinitionRegistry(...) 方法！"}],"slateId":"_k-efEfJU6U9FsnoZuj0a"},{"type":"Heading3","children":[{"text":"1.BFPP的实现方法"}],"slateId":"pCFgpE8Anf1RJF83mE7oW"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// MapperScannerConfigurer.class\n\npublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {\n // 核心类！！！创建扫描器\n ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);\n \n // 设置配置\n scanner.setAddToConfig(this.addToConfig);\n scanner.setAnnotationClass(this.annotationClass); // ← 使用@MapperScan，则为注解指定值，否则为null；若未使用@MapperScan,由MybatisAutoConfiguration.class注册的默认\nMapperScannerConfigurer.class,则该值为 Mapper.class\n scanner.setMarkerInterface(this.markerInterface);\n scanner.setSqlSessionFactory(this.sqlSessionFactory);\n scanner.setSqlSessionTemplate(this.sqlSessionTemplate);\n scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);\n scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);\n scanner.setResourceLoader(this.applicationContext);\n scanner.setBeanNameGenerator(this.nameGenerator);\n scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass); // ← 默认 MapperFactoryBean.class\n\n // 设置哪些接口要被扫描（支持表达式、占位符）\n scanner.registerFilters();\n \n // ⭐⭐⭐ 执行扫描！\n scanner.scan(\n StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));\n}"}],"slateId":"ssfPoaayezhbnEC6w50pt"}],"slateId":"QvXcZH2x83ykVIOe4fmE6"},{"type":"Paragraph","children":[{"text":""}],"slateId":"gycxUiiJ4ffSGn5QQZFkU"},{"type":"Heading3","slateId":"kIu8icQEZ8gqPCq-LItji","children":[{"text":"2.ClassPathMapperScanner的扫描+改写BD的逻辑"}]},{"type":"Paragraph","children":[{"text":"上文代码中的"},{"text":"ClassPathMapperScanner.class","code":true},{"text":"继承自Spring框架的的ClassPathBeanDefinitionScanner（!!!利用Spring框架现成的类扫描能力，即ClassPathBeanDefinitionScanner）"}],"slateId":"PDCf2dWudZIVm-x9lqYmI"},{"type":"Paragraph","slateId":"uWMBmiv3k65acBXEHDnh0","children":[{"text":"类签名："},{"text":" public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner","code":true}]},{"type":"Paragraph","slateId":"otm79nZeRfJAOwdqXCbfa","children":[{"text":"其主要能力为： "}]},{"type":"Paragraph","slateId":"c3N33oww_7U0nZ-YFZNTd","children":[{"text":" 1）持有BeanDefinition注册器实例， BeanDefinitionRegistry registry"}]},{"type":"Paragraph","slateId":"z1hqAbnj0GfOvUwP-cSH4","children":[{"text":" 2) 使用自己的接口过滤器逻辑registerFilters(...)，扫描指定包下的所有接口/或被@Mapper修饰的接口（由是否使用@MapperScan注解来决定）; 父类ClassPathBeanDefinitionScanner.class的过滤器为registerDefaultFilters(......)，其逻辑为过滤所有带有@Component注释的类"}]},{"type":"Paragraph","slateId":"VhDUvAwhdvixEb9F-ohAZ","children":[{"text":" 3）根据scanner配置, 调用ClassPathMapperScanner. scan(...)"}]},{"type":"Paragraph","slateId":"LGGgQvJ2fiPrJQQblDBcv","children":[{"text":" a. 扫描出符合条件的每个接口，将其转换为BeanDefinition并注册收到Spring中"}]},{"type":"Paragraph","slateId":"LEjmHiRt9pAOoerJ0ungj","children":[{"text":" b. 调用this.processBeanDefinitions(...)处理扫描到的每个BeanDefinition：将每个接口的BeanDefinition修改为 MapperFactoryBean.class 的 BeanDefinition"}]},{"type":"Paragraph","slateId":"ND2P1rec2GX8114eqPneh","children":[{"text":"doScan() 与 processBeanDefinitions（）的简化代码如下："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 有如下继承关系 ClassPathMapperScanner --extends--> ClassPathBeanDefinitionScanner\n\n// ClassPathBeanDefinitionScanner.class （Spring框架的类）\npublic class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {\n private final BeanDefinitionRegistry registry;\n \n public int scan(String... basePackages) {\n ......\n doScan(basePackages);\n .......\n }\n}\n\n\n// ClassPathMapperScanner.class (spring-mybatis的类)\npublic class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {\n \n // 重写父类doScan()方法\n @Override\n public Set doScan(String... basePackages) {\n // 1. 调用父类（Spring 的 ClassPathBeanDefinitionScanner）扫描候选类\n // 这里把所有Mapper接口都扫描到了，且生成了对应BD\n Set beanDefinitions = super.doScan(basePackages);\n\n if (beanDefinitions.isEmpty()) {\n .....\n } else {\n // 2. ⭐⭐⭐ 关键：处理扫描到的每个BD\n processBeanDefinitions(beanDefinitions);\n }\n return beanDefinitions;\n }\n\n // --------------------！！！关键：将xxxMapper接口的BeanDefinition修改为 MapperFactoryBean\n private void processBeanDefinitions(Set beanDefinitions) {\n AbstractBeanDefinition definition;\n BeanDefinitionRegistry registry = getRegistry();\n for (BeanDefinitionHolder holder : beanDefinitions) {\n definition = (AbstractBeanDefinition) holder.getBeanDefinition();\n\n // 1. 获取原始类名\n String beanClassName = definition.getBeanClassName();\n\n // 2. ⭐⭐⭐ 关键：把接口的 BeanDefinition 改造成 MapperFactoryBean！\n // 2.1 传给 MapperFactoryBean 构造函数的参数：new MapperFactoryBean(xxxMapper.class)\n definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);\n try {\n Class beanClass = Resources.classForName(beanClassName);\n // 2.2 告诉 Spring：泛型 FactoryBean 的对象类型（T）是 xxxMapper.class（用于泛型推断、AOT 编译等）\n definition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, beanClass); \n // 2.3 设置MapperFactoryBean的成员变量mapperInterface值，指定当前MapperFactoryBean负责代理哪个Mapper,后续在生成Mapper代理对象时会用到\n definition.getPropertyValues().add(\"mapperInterface\", beanClass); \n } catch (ClassNotFoundException ignore) { \n // ignore\n }\n \n // 2.4 把 Bean 类型从 xxxMapper 改为 MapperFactoryBean(this.mapperFactoryBeanClass 实际值为MapperFactoryBean.class）\n definition.setBeanClass(this.mapperFactoryBeanClass); \n\n // 2.5 ⭐⭐⭐ 关键将 SqlSessionFactory / SqlSessionTemplate 引用，加入MapperFactoryBean中, \n definition.getPropertyValues().add(\"sqlSessionFactory\", this.sqlSessionFactory);\n definition.getPropertyValues().add(\"sqlSessionTemplate\", this.sqlSessionTemplate);\n\n // 3. 配置是否懒加载，来自 @MapperScan(lazyInitialization = true)\n definition.setLazyInit(lazyInitialization);\n \n ........\n }\n } \n}"}],"slateId":"OAC6njttt937EwfCER7Ji"}],"slateId":"sqsY4AYz-BGSRqrXeycil"},{"type":"Paragraph","children":[{"text":"执行 processBeanDefinitions 后："}],"slateId":"y-9kCXDq49zR_ue8LE1CH"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"O4oSoQwJ1vLzrJ6BbtV7P","children":[{"text":"BeanName","bold":true},{"text":": userMapper"}]}],"slateId":"Za6oxTT3efqDZih5mtwGG"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"baVB88IJDRY5djxAguPyW","children":[{"text":"BeanClass","bold":true},{"text":": org.mybatis.spring.mapper.MapperFactoryBean (Bean类型变成了工厂类!!!，在初始化时spring会使用该工程生成T类型的实例，而不是new，这是利用spring框架的特性 )"}]}],"slateId":"HJTdmHinYFlKbg4c3mbXz"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"YmTREdbDZJ_5Ki-gRNK8q","children":[{"text":"ConstructorArgs","bold":true},{"text":": [com.example.UserMapper](告诉工厂生产谁)"}]}],"slateId":"wlqfhzYLgE4s_EMYp098j"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"5OUBhF9YroVkzI-hTTB_e","children":[{"text":"PropertyValues","bold":true},{"text":":"}]}],"slateId":"pO6hlPBIWkkZwuIT_qWj6"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"RB0piTs3frNEmMdDTA80M","children":[{"text":"mapperInterface","bold":true},{"text":" = com.example.UserMapper.class"}]}],"slateId":"DaKBDtQj8fqVPRuS4CpBK"}],"slateId":"jI37OoZUBjuuQkt8Wza8I"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"hJ93_Wve1mio5t7h15JXv","children":[{"text":"sqlSessionFactory","bold":true},{"text":" = (自动按类型注入)"}]}],"slateId":"Oe6dhKoWMrixLsRe2foli"}],"slateId":"o80Tijp-4RCvQvfcMyg5g"},{"type":"Heading2","children":[{"text":"3. 重点：（userMapper如何实例化）MapperFactoryBean从BD实例化为Bean"}],"slateId":"7QyBECYTw4J8NwVUq-J7q"},{"type":"Paragraph","children":[{"text":"Spring将 MapperFactoryBean从BD实例化为Bean的时机主要有两个："}],"slateId":"17d8YZkP2EI9iLGG5eIoq"},{"type":"Paragraph","slateId":"O8RxCYNSAWulnK27X7PRy","children":[{"text":" a. 时机（懒加载）：当其他 Bean（如 UserService）需要 UserMapper 时"}]},{"type":"Paragraph","slateId":"JNDlx0KHUGuyx4pZJXaKp","children":[{"text":" b. 时机（正常实例化）：容器启动时（如果依赖它的 Service 是单例且 eager-initialized）"}]},{"type":"Paragraph","slateId":"LtdMlTp9waaXJjQKxslRb","children":[{"text":"BD实例化为Bean主要是以下逻辑，详细分析可以参考另一篇分析SpringBoot启动的文章"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 伪代码逻辑展示 Spring 内部处理 FactoryBean 的过程\n\n// 1. 创建 FactoryBean 实例 (MapperFactoryBean)\nObject factoryBean = createBeanInstance(...);\n\n// 2. 注入属性 (setSqlSessionFactory, setMapperInterface 等)\npopulateBean(factoryBean, ...);\n\n// 3. 调用初始化方法 (InitializingBean.afterPropertiesSet())\n// >>> 这里先执行 afterPropertiesSet() <<<\ninvokeInitMethods(beanName, factoryBean, mbd); \n\n// 4. 将 FactoryBean 注册到工厂内部缓存 (如果是单例)\n\n// 5. 当用户请求 Bean (getBean(\"userMapper\")) 时\nif Spring 发现这是一个 FactoryBean\n { // \n 于是调用 getObject()\n // >>> 这里后执行 getObject() <<<\n Object userMapperProxy = ((FactoryBean) factoryBean).getObject();\n }"}],"slateId":"vt_dmCLb-ZZ＊＊＊tmpoF2L"}],"slateId":"oNkt_5CSWegTKkB0rB84U"},{"type":"Paragraph","children":[{"text":"创建过程","bold":true},{"text":"： "}],"slateId":"jvXx1pqFnKbBcueFIIzzA"},{"type":"Paragraph","slateId":"C96yVc7Hl7ujGiA7vKxHK","children":[{"text":" 1.Spring "},{"text":"创建 MapperFactoryBean 实例","bold":true},{"text":"（调用构造函数），注入 sqlSessionTemplate、mapperInterface 等依赖"}]},{"type":"Paragraph","slateId":"VcPvbDdc5iP0kC61VxmlS","children":[{"text":" 2. 由于MapperFactoryBean.class 继承了DaoSupport.class(其实现了InitializingBean接口，会调用afterPropertiesSet()方法)"}]},{"type":"Paragraph","slateId":"2kzEzUkjGMZuPpEuSqqav","children":[{"text":" 3. 调用 FactoryBean.getObject(), 这里实际是调用MapperFactoryBean.getObject()"}]},{"type":"Paragraph","slateId":"Rag1BMAVAFZM8L5OACE3X","children":[{"text":""}]},{"type":"Paragraph","slateId":"GCXBHmLQalEvBrksD-5Qp","children":[{"text":""}]},{"type":"Heading3","children":[{"text":"3.1 检查成员MapperFactoryBean的变量、向Mybatis注册Mapper"}],"slateId":"eWOxhjGOY6JdmZBFctD3T"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"继承关系：\nMapperFactoryBean ---extends---> SqlSessionDaoSupport ----extends---> DaoSupport ---implements---> InitializingBean\n |-------------------implements-------------------> FactoryBean (实际上就是个BeanDefinition)\n\n /**\n** DaoSupport.class\n*/\npublic final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {\n this.checkDaoConfig();\n ......\n}\n\n/**\n** MapperFactoryBean.class\n** afterPropertiesSet()会调用checkDaoConfig() \n*/\n@Override\nprotected void checkDaoConfig() {\n // 1. 检查this.sqlSessionTemplate是否为空\n super.checkDaoConfig();\n // 2. 检查this.mapperInterface是否为空\n notNull(this.mapperInterface, \"Property 'mapperInterface' is required\");\n \n // 3. 从SqlSessionTemplate.SqlSessionFactory获取Configuration，检查当前Mapper是否已注册（避免重复）\n Configuration configuration = getSqlSession().getConfiguration();\n if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {\n //4. 【核心】将 Mapper 接口注册到 MyBatis的Configuration.getMapperRegistry().getKnownMappers() (knownMappers这个map相当于一个注册表)\n configuration.addMapper(this.mapperInterface);\n }\n}\n\n/**\n** MapperRegistry.addMapper()\n*/\npublic void addMapper(Class type) {\n //【使用反射】检查接口是否合法\n if (type.isInterface()) {\n // 检查当前Mapper是否存在于 Resource的注册表中\n if (hasMapper(type)) throw ...;\n \n //向Resource的注册表中新增MapperProxyFactory\n knownMappers.put(type, new MapperProxyFactory<>(type));\n }\n} "}],"slateId":"QSI-_epMzlTU4hcTckwq-"}],"slateId":"JFSwIoiRH_3QoguRi7zTu"},{"type":"Paragraph","children":[{"text":""}],"slateId":"4JvJuh5gklddrYKqzh7cr"},{"type":"Heading3","slateId":"3sDgbiyEoqiFDpA8djCFw","children":[{"text":"3.2 生成代理逻辑"}]},{"type":"Paragraph","children":[{"text":"MapperProxy代理类的业务逻辑：这里并未用到每个Mapper对应的XML文件，而是把对该代理的调用转发给 Mybatis"}],"slateId":"zz51nbIrKMncyzU-8TfXe"},{"type":"Paragraph","slateId":"N10r1G79UziCV_szYtNb9","children":[{"text":"MapperFactoryBean.getObject()源码："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@Override\npublic T getObject() throws Exception {\n // getSqlSession()获取的是在上文中，为MapperFactoryBean设置的SqlSessionTemplate值，该值是一个单例\n // this.mapperInterface是上文中定义MapperFactoryBean的BeanDefinition时指定的xxxMapper的java.lang.Class实例\n return getSqlSession().getMapper(this.mapperInterface); \n}"}],"slateId":"qZS-t8KA-nA2XNnZWmvXO"}],"slateId":"BtdGX86tI8DnkwQUw429k"},{"type":"Paragraph","children":[{"text":"SqlSessionTemplate.getMapper()源码：（mybatis-spring.jar）"}],"slateId":"NgRpp_RAXAxSh8wyZSAJT"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@Override\npublic T getMapper(Class type) {\n // getConfiguration（）拿到的是 MyBatis 全局的 Configuration 对象（包含所有 Mapper 接口、SQL 映射等元数据）。\n return getConfiguration().getMapper(type, this);\n}"}],"slateId":"2vIckVO04377DplYkC4D7"}],"slateId":"T0CFfP17badpQk5sorLr1"},{"type":"Paragraph","children":[{"text":"Configuration.getMapper()源码：(mybatis.jar)"}],"slateId":"pXinDQ78rNwel_gP-N9AD"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public T getMapper(Class type, SqlSession sqlSession) {\n // MapperRegistry持有MyBatis 内部注册所有 Mapper 的组件\n return mapperRegistry.getMapper(type, sqlSession);\n}"}],"slateId":"Vl4yqwcdShgIjUzOchbM_"}],"slateId":"dxDJnn7bG27SR_pQYQhUa"},{"type":"Paragraph","children":[{"text":"重点！！！！"}],"slateId":"K_-5rk-M6EV3sfe9H6IYK"},{"type":"Paragraph","slateId":"N1wlvEfEnhpOZ8MJ_H6eM","children":[{"text":"MapperRegistry.getMapper()源码：(mybatis.jar)"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public T getMapper(Class type, SqlSession sqlSession) {\n // 在 MapperFactoryBean被Spring初始化完成后，对应的 Mapper 接口都会被注册到MapperRegistry的knownMappers这个Map中；\n final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);\n \n try {\n // ！！！关键：生成Mapper的代理实例\n return mapperProxyFactory.newInstance(sqlSession);\n } \n}"}],"slateId":"b-2MV2HqHLMKGO2h91Y7a"}],"slateId":"l7wSuHwEmXUNu_83PszFm"},{"type":"Paragraph","children":[{"text":"MapperProxyFactory.newInstance()源码："}],"slateId":"joWORAXFCYCTs-n9VNg32"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public T newInstance(SqlSession sqlSession) {\n // new 一个代理类MapperProxy，其是xxxMapper的代理类\n final MapperProxy mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);\n return newInstance(mapperProxy);\n}\n\nprotected T newInstance(MapperProxy mapperProxy) {\n // 基于JDK动态地理，使用mapperProxy代理当前xxxMapper接口，即this.mapperInterface引用指向的类\n return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);\n}"}],"slateId":"3dvfvsADpjmhWIak8sij0"}],"slateId":"Qo4qm4q33z_TossPsLi5A"},{"type":"Paragraph","children":[{"text":"结论： userMapper最终会被一个MapperProxy实例所代理","bold":true}],"slateId":"4cVjSbZk57ChelUYL1VPu"},{"type":"Paragraph","slateId":"uCRQ86xXG64WRw3uPZz5y","children":[{"text":"衍生问题","bold":true},{"text":"：“MapperFactoryBean为什么还要通过实现InitializingBean接口先把 MapperProxyFactory 存到 Configuration.knownMappers中，之后又取出来用？为什么不直接在 MapperFactoryBean.getObject() 里 new MapperProxyFactory(...).newInstance(...)，绕过 knownMappers？”"}]},{"type":"Paragraph","slateId":"X0A2LzHPRNfvLvcjvJmNi","children":[{"text":" MyBatis-Spring 的设计哲学是：松耦合、高内聚、可扩展架构"}]},{"type":"Paragraph","slateId":"ljdAr2lEHIS0Ra4403DQT","children":[{"text":" 宏观： MapperFactoryBean是mybatis-spring.jar包中的类，负责 Spring Bean 生命周期，只负责“注册”MapperProxyFactory； Configuration + MapperRegistry 是mybatis.jar包中的类，MyBatis 负责“生产和管理” MapperProxy"}]},{"type":"Paragraph","slateId":"AoTAcP33X_R_d4Vt5EECh","children":[{"text":""}]},{"type":"Heading2","slateId":"NQHzgtfBH-uBGcFBnoAci","children":[{"text":"4. MapperProxy代理的invoke()方法逻辑（当业务调用Mapper时，sql如何执行）："}]},{"type":"OrderedList","children":[{"type":"ListItem","children":[{"text":"接口调用","bold":true},{"text":"：你调用接口方法。"}],"slateId":"SdiMvnBS6Tzn7R2sqpRZc"},{"type":"ListItem","slateId":"SG15hPj2ILlNmHuSRDSWJ","children":[{"text":"代理拦截 (MapperProxy.invoke())","bold":true},{"text":"："}]},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"tZDyvZKzgVaZkzHmvu45r","children":[{"text":"代理对象根据方法签名，从缓存中获取 MapperMethod 对象。"}]},{"type":"ListItem","slateId":"SIcq1dJvqEEdAY7AK-btx","children":[{"text":"(注意：MapperMethod 内部持有了对应 MappedStatement 的 ID)"}]}],"slateId":"C8Tdv8fXrcF1h809eCiE_"},{"type":"ListItem","slateId":"b_kbcqKtnJ6Bzywr2Kk3w","children":[{"text":"方法执行 (MapperMethod.execute())","bold":true},{"text":"："}]},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"WLM-oKrY7msdSt6jKHZpl","children":[{"text":"MapperMethod 调用当前线程的sqlSession.selectOne(...)。"}]},{"type":"ListItem","slateId":"Syte_lCyq2guwg_ZtONrj","children":[{"text":"关键点：此时，sqlSession 会去全局 Configuration 中，根据 ID 获取 MappedStatement 对象。"}]}],"slateId":"HPGUuN2CuafL0OrBhkBmP"},{"type":"ListItem","slateId":"VsP9Xbx_ZYcXHT7K7DKs1","children":[{"text":"Executor 登场 (executor.query)："}]},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"GLEGQNECYlVoMURwJf_-O","children":[{"text":"DefaultSqlSession 调用executor.query(ms, parameter, ...)。"}]},{"type":"ListItem","slateId":"kyE26L7fOeCFb90Y2DPgu","children":[{"text":"注意参数：这里的第一个参数 ms 就是 MappedStatement。"}]},{"type":"ListItem","slateId":"p_OxnkudjtWjFIGBlALEu","children":[{"text":"Executor 拿着这个 ms，从中取出 SqlSource，进而生成 BoundSql，最终执行数据库操作。（每个sqlSession都持有一个单独的Executor实例）"}]}],"slateId":"D6bUOwcJ5rJrJJZajTfOk"}],"slateId":"0w2ZHRzsqxi99zyQFYOt3"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"UserMapper (接口)\n ↑\n | (代理)\n |\nMapperProxy (代理对象)\n │\n ↓\nMapperMethod (方法逻辑) ────── 1. new MapperMethod（...）时，通过当前方法Method，解析其在mybatis中对应的sqlID,（即，MS 的 ID）\n │\n ↓\nSqlSession (DefaultSqlSession) ── 2. 根据 ID 从 Configuration 获取 MappedStatement\n │\n ↓\nExecutor (执行器) ──────────── 3. 接收 MappedStatement 作为参数\n │ ↓\n │ 4. 从 MS 中读取 SqlSource\n │ ↓\n │ 5. 生成 BoundSql (最终 SQL)\n ↓\nDatabase"}],"slateId":"jC4TqfHKmBLiXLsfoY96H"}],"slateId":"BLdUpGrgZDrelGKLw8q77"},{"type":"Paragraph","children":[{"text":"所有JDK动态代理的代理类，都要实现InvocationHandler接口；"}],"slateId":"1hyE1jiggihLmLcISsdSa"},{"type":"Paragraph","slateId":"ujL4n_eY7qfejjbXrc2sZ","children":[{"text":" 当调用被代理类xxxMapper.xxxMethod()时，实际是在调用 MapperProxy.invoke(Method xxxMethod)"}]},{"type":"Paragraph","slateId":"ej9Mc6_GvzUp_j05c4Mvp","children":[{"text":"MapperProxy实现InvocationHandler接口，实现其方法invoke（）"}]},{"type":"Paragraph","slateId":"pr07aBiw32Rse1Uq475rt","children":[{"text":""}]},{"type":"Paragraph","slateId":"GmgeZ9YJyfYMvos2cfrok","children":[{"text":"假设 Service 代码：userMapper.selectById(1L)。"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public class MapperProxy implements InvocationHandler, Serializable {\n // jdk动态代理会拦截对userMapper实例中任何方法的调用，\n // 然后调用Invoke()方法\n @Override\n public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n try {\n // 1. 如果是 Object 的方法（如 toString, hashCode），直接调用\n if (Object.class.equals(method.getDeclaringClass())) {\n return method.invoke(this, args);\n }\n\n // 2. 策略模式：使用 cachedInvoker(method) 获取不同的 Invoker， Invoker 接口来解耦不同方法类型的调用策略（如普通方法、默认方法）\n // 这里的执行过程： method 对应的 mapperMethod执行 mapperMethod.execute(sqlSession, args);\n return cachedInvoker(method).invoke(proxy, method, args, sqlSession);\n } \n }\n\n // MapperMethodInvoker是一个基于策略模式的接口\n private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {\n // 解析获取MapperMethodInvoker开销大，使用Map缓存起来\n return MapUtil.computeIfAbsent(methodCache, method, m -> {\n if (!m.isDefault()) {\n // ！！！重点：对于普通 Mapper 方法（非 default、非 Object）\n return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));\n }\n // Mapper接口中的Default方法处理逻辑（暂不展开分析）\n .........\n return new DefaultMethodInvoker(getMethodHandleJava9(method));\n }\n }\n\n private static class PlainMethodInvoker implements MapperMethodInvoker {\n private final MapperMethod mapperMethod;\n\n public PlainMethodInvoker(MapperMethod mapperMethod) {\n this.mapperMethod = mapperMethod;\n }\n\n @Override\n public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {\n // ！！！！核心执行逻辑 , 这里的sqlSession 就是全局唯一的SqlSessionTemplate单例。\n return mapperMethod.execute(sqlSession, args);\n }\n }\n }\n\n\n// MapperMethod.class\npublic class MapperMethod {\n\n private final SqlCommand command;\n private final MethodSignature method;\n\n public MapperMethod(Class mapperInterface, Method method, Configuration config) {\n // 通过当前方法Method，解析其在mybatis中对应的sqlID,并获取sqlId对应的MapperStatement\n this.command = new SqlCommand(config, mapperInterface, method);\n this.method = new MethodSignature(config, mapperInterface, method);\n }\n \n public static class SqlCommand {\n\n private final String name; // MS 的 ID\n private final SqlCommandType type;\n\n public SqlCommand(Configuration configuration, Class mapperInterface, Method method) {\n final String methodName = method.getName();\n final Class declaringClass = method.getDeclaringClass();\n // 根据被代理对象的methodName，获取到mybatis上下文（即configuration）中已经注册的MapperStatement\n // resolveMappedStatement 方法会根据接口全限定名 + \".\" + 方法名（例如 com.example.mapper.UserMapper.findById）作为 key，去 Configuration 对象中查找预先加载好的 MappedStatement。\n MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass, configuration);\n name = ms.getId();\n type = ms.getSqlCommandType();\n }\n \n // 根据MapperStatement定义的sql类型（也就是xxxmapper.xml定义的sql类型，来决定调用SqlSession接口的不同方法）\n public Object execute(SqlSession sqlSession, Object[] args) {\n Object result;\n switch (command.getType()) {\n case INSERT: {\n Object param = method.convertArgsToSqlCommandParam(args);\n result = rowCountResult(sqlSession.insert(command.getName(), param));\n break;\n }\n .......\n case SELECT:\n Object param = method.convertArgsToSqlCommandParam(args);\n result = sqlSession.selectOne(command.getName(), param);\n if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) {\n result = Optional.ofNullable(result);\n }\n break;\n .......\n }\n return result;\n } \n}"}],"slateId":"dHo2uvOlViXJBVv-i2XkT"}],"slateId":"DQpgHllWZsBZz2y4Vhy33"},{"type":"Paragraph","children":[{"text":"结论","bold":true},{"text":"：每个xxmapper被一个MapperProxy实例所代理，所有MapperProxy持有同一个SqlSessionTemplate的引用（SqlSession的实现类，全局唯一），这是最终sql执行的入口；"}],"slateId":"rrWyOLpf2aEvbMDjem5Il"},{"type":"Paragraph","slateId":"Lcz5IhF9geKTJcZ2sLZSF","children":[{"text":" MapperProxy每次被调用时，通过被代理对象的被调用方法名（methodName），new一个 MapperMethod， MapperMethod再将执行委托给 SqlSessionTemplate来执行"}]},{"type":"Paragraph","slateId":"V14NSkDxyquXYZo_YbRdp","children":[{"text":""}]},{"type":"Heading1","slateId":"YJPUCCUeV9DhUCf6T6xXP","children":[{"text":"四、（补充）SqlSessionTemplate如何执行一个sql"}]},{"type":"Heading2","children":[{"text":"1. SqlSessionTemplate是单例"}],"slateId":"f5JxcLFcqHJ1d4jzAyHLL"},{"type":"Paragraph","children":[{"text":"MapperProxy (每个 Mapper 一个)"}],"slateId":"SIVWsFsgsNo-oYCIjDqAV"},{"type":"Paragraph","slateId":"M7irygqvpvesqRjxPQPSH","children":[{"text":"持有了 -> SqlSessionTemplate (全局唯一单例)"}]},{"type":"Paragraph","slateId":"4agaEUCJ_OdwxZsvXhpKp","children":[{"text":" 内部包含 -> sqlSessionProxy (JDK 动态代理)"}]},{"type":"Paragraph","slateId":"jkuJdZMOTcPCc5AMviCSF","children":[{"text":" 拦截调用 -> SqlSessionInterceptor"}]},{"type":"Paragraph","slateId":"aCoDyaCobhZKsiX4ISOIb","children":[{"text":" 获取/管理 -> DefaultSqlSession (真正的 MyBatis 会话，线程隔离)"}]},{"type":"Paragraph","slateId":"XDQSIsNs7T7L30ShKrSxU","children":[{"text":"Q: 为什么这样设计？ ","bold":true}]},{"type":"Paragraph","slateId":"a4Zhry9HJCEe_nLsKJbmG","children":[{"text":" 正是因为共享了这个 SqlSessionTemplate，它才能利用内部的 ThreadLocal 机制，确保同一个线程（同一个事务）内的不同 Mapper 调用，都能获取到同一个底层的 DefaultSqlSession，从而实现事务的一致性。"}]},{"type":"Heading2","slateId":"mlH0k3pD2RJMczLxkgLLw","children":[{"text":"2.空壳代理 SqlSessionProxy获取SqlSession"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public class SqlSessionTemplate implements SqlSession, DisposableBean {\n\n private final SqlSessionFactory sqlSessionFactory;\n private final ExecutorType executorType;\n private final SqlSession sqlSessionProxy; //非常重要： MapperMethod委托给SqlSessionTemplate的sql调用， SqlSessionTemplate都会再次委托给 sqlSessionProxy\n\n public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {\n ......\n this.sqlSessionFactory = sqlSessionFactory;\n this.executorType = executorType;\n this.exceptionTranslator = exceptionTranslator;\n // 重点!!! sqlSessionProxy是一个空壳代理，实际逻辑被SqlSessionInterceptor代理执行\n this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),\n new Class[] { SqlSession.class }, new SqlSessionInterceptor());\n }\n\n @Override\n public T selectOne(String statement, Object parameter) {\n return this.sqlSessionProxy.selectOne(statement, parameter);\n }\n \n @Override\n public List selectList(String statement) {\n return this.sqlSessionProxy.selectList(statement);\n }\n ...............\n\n // sqlSessionProxy的JDK动态代理类\n private class SqlSessionInterceptor implements InvocationHandler {\n @Override\n public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n // ------------------ 1. 获取一个sqlSession -------------------\n //！！！如果存在事务，则事务范围内，不同mapper拿到的SqlSession是同一个实例\n SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,\n SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);\n try {\n // ------------------2. 执行DefaultSqlSession对sql调用的实现--------------------\n Object result = method.invoke(sqlSession, args);\n if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {\n // force commit even on non-dirty sessions because some databases require\n // a commit/rollback before calling close()\n // -------------------3. commit ------------------------\n sqlSession.commit(true);\n }\n return result;\n } catch (Throwable t) {\n ...........\n } finally {\n if (sqlSession != null) {\n // ------------------------5. close sqlSession 释放资源 ----------------------\n closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);\n }\n }\n }\n }\n}"}],"slateId":"KD__8dBs5yPGKO89FJhfD"}],"slateId":"Bw-rssarUR7eoc1umOO89"},{"type":"Heading2","slateId":"QykOyskfLyr5OxFD8KpCs","children":[{"text":"3. 为什么要设计成“空壳代理”？"}]},{"type":"Paragraph","slateId":"KyKk2g7N7fc-z5ivqgRNt","children":[{"text":"Q：“为什么不直接在 SqlSessionTemplate 方法里获取 DefaultSqlSession 然后调用，非要搞这个 sqlSessionProxy 成员变量？”"}]},{"type":"Paragraph","slateId":"bMk-4-qNxrYrpVjWpZt8m","children":[{"text":"A：为了复用代码；如果让SqlSessionTemplate去实现每一个SqlSession接口的方法，那必然有一大堆重复的处理Session与事务的代码，"}]},{"type":"Paragraph","children":[{"text":""}],"slateId":"05tPKdgBFWRf94Q02ZZ-f"},{"type":"Heading2","slateId":"kKDqGfSnYMpBmvY0zCDlp","children":[{"text":"4. getSqlSession与closeSqlSession的运行原理"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// SqlSessionUtils.class\n// 这是一个静态工具方法\npublic static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {\n // SqlSessionHolder实例就是注册到线程变量中的被包装的DefaultSqlSession（为了支持事务相关功能）\n SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);\n // session != null则证明当前线程的本次mapper调用，处于某个事务范围内，则从线程变量中获取已存在的DefaultSqlSession\n SqlSession session = sessionHolder(executorType, holder);\n if (session != null) {\n return session; \n }\n\n // session == null 有三种情况：\n // 1. 如果这次mapper方法调用没有被@Transactional注解，即不是事务sql\n // 2. SpringBoot显式配置关闭事务支持\n // 3. 这是当前线程，在当前事务范围内执行的第一个sql\n LOGGER.debug(() -> \"Creating a new SqlSession\");\n session = sessionFactory.openSession(executorType);\n // 如果与事务相关（判断过程再registerSessionHolder中，此处不再展开），则向线程变量注册当前session\n registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);\n\n return session;\n}\n\n\npublic static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {\n var holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);\n // 做事务相关处理\n if (holder != null && holder.getSqlSession() == session) {\n LOGGER.debug(() -> \"Releasing transactional SqlSession [\" + session + \"]\");\n holder.released();\n } else {\n // 关闭当前DefaultSqlSession\n LOGGER.debug(() -> \"Closing non transactional SqlSession [\" + session + \"]\");\n session.close();\n }\n}"}],"slateId":"9l9IivEtSgyfNWvuBlnZu"}],"slateId":"tc_g0cMMuNnmEWJPdIGhY"},{"type":"Paragraph","children":[{"text":"TransactionSynchronizationManager本质上是一个静态工具类，其维护了多个ThreadLocal变量，包括与事务相关的resource"}],"slateId":"KdSzgM7dL80IgsIBU9xYw"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public abstract class TransactionSynchronizationManager {\n private static final ThreadLocal> resources = new NamedThreadLocal<>(\"Transactional resources\");\n ......\n}"}],"slateId":"2r-itWLeu-aYWDBthKtaH"}],"slateId":"rigQwZm5GCFGbHno73FBd"},{"type":"Paragraph","children":[{"text":""}],"slateId":"Lm8k9fZLzEBi2-DRrOTv7"},{"type":"Heading2","slateId":"11FqvYRynzsIT_iOv26J6","children":[{"text":"5. DefaultSqlSession如何执行"}]},{"type":"Paragraph","children":[{"text":"最终，所有的mapper调用，由SqlSessionTemplate -> SqlSessionProxy -> SqlSessionInterceptor拦截后 -> 反射调用DefaultSqlSession的方法，都落到了DefaultSqlSession的方法调用上。"}],"slateId":"09KIa3PzL9iTEADiFRJIb"},{"type":"Paragraph","slateId":"1bWCBr71LvVev2bNelcDR","children":[{"text":"以DefaultSqlSession的selectList( )方法为例："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"//---------------- DefaultSqlSession.class ---------------\nprivate List selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {\n try {\n MappedStatement ms = configuration.getMappedStatement(statement);\n ......\n // 调用 CachingExecutor\n return executor.query(ms, wrapCollection(parameter), rowBounds, handler);\n } \n}"}],"slateId":"dHfI2XgRY4pGWpGur8hXb"}],"slateId":"Rs70m-S6fWVjlKNw42zT_"},{"type":"Paragraph","children":[{"text":"Executor的执行采用了委托者模式"}],"slateId":"cm1XlDo-_2w8sp4VNXc02"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"CachingExecutor (负责二级缓存)\n ↓ 委托 (delegate)\nSimpleExecutor (负责具体执行策略)\n ↑ 继承\nBaseExecutor (抽象类，负责一级缓存和通用逻辑)\n\n//------------------ CachingExecutor.class---------------\npublic List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {\n // 从SqlSource拼装最后的sql\n BoundSql boundSql = ms.getBoundSql(parameterObject);\n // 处理二级缓存\n CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);\n ..............\n return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);\n}\n\n// ------------------BaseExecutor.class--------------\npublic List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,\n CacheKey key, BoundSql boundSql) throws SQLException {\n // 处理一级缓存\n ...........\n // 调用抽象类模版方法\n list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);\n ................\n return list;\n}\n\n// ---------------------SimpleExecutor.class -------------------\n public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {\n Statement stmt = null;\n try {\n Configuration configuration = ms.getConfiguration();\n // StatementHandler 负责协调 JDBC 操作。它内部会创建 ParameterHandler 来设置 SQL 参数，以及使用构造函数入参的 ResultSetHandler 来将数据库返回的结果集转换成 Java 对象。\n StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);\n // 当前SqlSession第一次执行sql时，从数据源( or 数据库连接池)或事务管理器中获取一个 Connection；后续会复用这个connection，直到SqlSess被销毁（即commit被执行）\n Connection connection = getConnection(ms.getStatementLog());\n stmt = handler.prepare(connection, transaction.getTimeout());\n // 来遍历 SQL 中的 ? 占位符，并使用 ParameterHandler 将 Java 参数设置进去。\n handler.parameterize(stmt);\n // 将真正执行 SQL 的任务再次委托给 StatementHandler。会调用 stmt.executeQuery() 执行 SQL。\n // 执行完毕后，它会获取 ResultSet，并交给内部的 ResultSetHandler 进行结果集映射，最终转换成一个 Java 对象的 List 返回。\n return handler.query(stmt, resultHandler);\n } finally {\n closeStatement(stmt);\n }\n }"}],"slateId":"7BAxzr5ebUfBvV-Bx3314"}],"slateId":"lAMmyv5PPTI5kN94Slu5z"},{"type":"Paragraph","children":[{"text":""}],"slateId":"ZPNe-bYUfBO97rlF9oQtT"},{"type":"Heading1","slateId":"teSC3UxkTK5AnjLV5oEtq","children":[{"text":"五、缓存（mybatis作为ORM层的缓存功能）"}]},{"type":"Paragraph","children":[{"text":"mybatis通常有三级缓存：其中一、二级缓存时Mybatis源码逻辑中自带的，三级缓存是外挂中间件来扩展的"}],"slateId":"IKCHi9uhDt2ATWLEIqR5L"},{"type":"Heading2","slateId":"4WY8etUxd-8_lanrep2_5","children":[{"text":"1. 一级缓存：SqlSession级别"}]},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"生命周期：它与 SqlSession 的生命周期完全同步。SqlSession 创建时缓存诞生，SqlSession 关闭或清空时缓存销毁；所以一级缓存能够提升一个事务内的重复sql查询效率"}],"slateId":"uyCxCBVU8Eup6ugCg8pkh"}],"slateId":"ZBscNmF6CcBPINl5h8g64"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"JGzC9S6cmFWhXKqDC9XSy","children":[{"text":"开关配置：一级缓存默认开启，通过mybatis-config.xml配置来实现关闭"}]}],"slateId":"WShADwnplfD19VMUhbNKO"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"tZKnBOvJb5IY915pEZ6fu","children":[{"text":"存储位置：一级缓存的核心载体是 BaseExecutor 类中的一个成员变量 localCache。BaseExecutor 是 MyBatis Executor的抽象基类，而 Executor 对象是由 SqlSession 持有和使用的。因此，localCache 自然就成了 SqlSession 的私有财产。"}]}],"slateId":"c0WHZ3YWNFX3vti_XeOrd"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 源码来自 org.apache.ibatis.executor.BaseExecutor\npublic abstract class BaseExecutor implements Executor {\n // 一级缓存，基于 PerpetualCache 实现，本质是一个 HashMap\n protected PerpetualCache localCache = new PerpetualCache(\"LocalCache\");\n // ...\n}"}],"slateId":"MOdQYyehIy8W2P0zxlF34"}],"slateId":"lBspeU5HPiZx-xdMRQFXx"},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"缓存时机：在 BaseExecutor 的 query 方法中，会首先尝试从 localCache 中获取数据。如果未命中，则查询数据库，并将结果存入 localCache。"}],"slateId":"l3cfPNEOfIYPaRvDtDrUO"}],"slateId":"rxE7XmMsCYwKAC8kzlOCU"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 简化后的 BaseExecutor.query 逻辑\npublic List query(...) {\n // 1. 先从一级缓存中获取\n List list = (List) localCache.getObject(key);\n if (list != null) {\n return list; // 命中缓存，直接返回\n }\n // 2. 未命中，查询数据库\n list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);\n // 3. 将查询结果写入一级缓存\n localCache.putObject(key, list);\n return list;\n}"}],"slateId":"lVd228_QBo83gsaNSSItP"}],"slateId":"Cmw9YPEp7ahAhCTIPjSH3"},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"失效时机：当 SqlSession 执行任何增删改（insert/update/delete）操作时，都会调用 BaseExecutor 的 flush 方法，该方法会清空 localCache，确保不会读到旧数据。"}],"slateId":"ERIHxW3oHjgZbh6P3zElG"}],"slateId":"Vb_nHdmNdQEQZqwHQbGwJ"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public int update(MappedStatement ms, Object parameter) throws SQLException {\n ErrorContext.instance().resource(ms.getResource()).activity(\"executing an update\").object(ms.getId());\n if (closed) {\n throw new ExecutorException(\"Executor was closed.\");\n }\n // 清空localCache中的所有缓存数据\n clearLocalCache();\n return doUpdate(ms, parameter);\n}"}],"slateId":"dOBYD0OLcbyto5apig5NK"}],"slateId":"cuKn3z1lxSAclEO_c7dqJ"},{"type":"Paragraph","children":[{"text":""}],"slateId":"JV7oWs2urTeOy_cQO-QHb"},{"type":"Heading2","slateId":"X5S1o4lY-ZGbjmJ4xxHT0","children":[{"text":"2. 二级缓存：mapper级别（mapper级别）"}]},{"type":"Paragraph","children":[{"text":"先说结论","bold":true},{"text":"：通常情况下，不开启二级缓存；因为现代应用基本都不是单体应用，使用默认的二级缓存配置，存在各应用实例间数据不同步问题"}],"slateId":"SzfrAdzu9t7Xfwwryq-0F"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"Tt3aqu1wiJfh3isrTZxgH","children":[{"text":"生命周期：与Spring应用的运行周期相关，不依赖于单个 SqlSession。"}]}],"slateId":"Mr60lxY1qz3X4H4t9vmwo"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"Fri1xf3qV359qEBcIUQro","children":[{"text":"开关配置："}]}],"slateId":"1Wk1T84zfLdqv4VzvViIe"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"ieE2GIA7o6wO9U5mETOQ5","children":[{"text":"yml文件显示配置 cacheEnabled = true"}]}],"slateId":"xNRGxRsWBtqSrep46Nvgn"}],"slateId":"YEaQQYvXqoqZMZsKz0Ejt"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"uirlEfeS4vLagPKiRD9O0","children":[{"text":"在你需要开启二级缓存的 Mapper.xml 文件中，添加子节点标签。"}]}],"slateId":"hoMkKdcBW8MUWO3VcfWNZ"}],"slateId":"9WBIqUMeYuvro9PqEVBsj"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"Rx5jccU3jLMe3LFO7tHPA","children":[{"text":"存储位置：二级缓存的核心由 CachingExecutor 和 MappedStatement 共同协作实现。二级缓存的 Cache 对象是绑定在 MappedStatement 上的。当你在 UserMapper.xml 中配置了标签后，MyBatis 在启动时就会为 UserMapper 这个 namespace 创建一个 Cache 对象，并将其关联到该 namespace （通常在配置xxxMapper.xml文件时，一个mapper对应一个nameSpace）下的所有 MappedStatement 中。（创建Cache对象并绑定到ms的过程发生在Mybatis自动装配SqlSessionFactory实例时）"}]}],"slateId":"GbdXtrzzoQLQSzKBjm3SR"},{"type":"BulletedList","children":[{"type":"ListItem","slateId":"JYBVaydf9uXvb4XQoYK4D","children":[{"text":"缓存时机：二级缓存的数据并不是查询完立刻写入的，而是在 SqlSession 提交（commit）或关闭（close）之后才真正写入。"}]}],"slateId":"W3dW6sDtell_bjsuoErWF"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"g51gdRUndTz3Brm4zMGaQ","children":[{"text":"失效/写入时机："}]}],"slateId":"Zs2n_wLDr920DU826I3CA"}],"slateId":"THj4b1fjdSlOdbtX8gAQW"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"q-WsyINTMJmih-x8fSBY8","children":[{"text":"如果事务提交：查询结果会被放入二级缓存；如果是更新操作，会触发缓存清空。"}]}],"slateId":"ieEU4r3Dn14UXF16LT9H8"}],"slateId":"y1p7Xw0DlJ8r0p_8jsd66"}],"slateId":"82xUlsM-NzecbLl4cLsKv"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"tuGGxwFY1SRzmemJ3sHDH","children":[{"text":"如果事务回滚：查询结果不会放入二级缓存；更新操作也不会触发缓存清空（因为数据没变）。"}]}],"slateId":"i9o4KZealA7HUCVffyqEz"}],"slateId":"71YLnQaca6KsVVkam3yd1"}],"slateId":"I1yoR5mMuQjqmcfVOuoKZ"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"o53t_e5_nkWfn-JSfvBPj","children":[{"text":"目的：防止“脏读”。如果事务未提交就把数据放入缓存，其他会话可能读到未提交甚至随后被回滚的数据。"}]}],"slateId":"Wy5pDegV7NgO7KMAAj9sk"}],"slateId":"sGptnIMKrjYiHtoSOl2hd"},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 简化后的 CachingExecutor.query 逻辑\npublic List query(...) {\n // 1. 从 MappedStatement 中获取该 namespace 对应的二级缓存对象\n Cache cache = ms.getCache();\n if (cache != null) { // 如果开启了二级缓存\n // 2. 尝试从二级缓存中获取数据\n List list = (List) cache.getObject(key);\n if (list != null) {\n return list; // 命中二级缓存，直接返回\n }\n // 3. 未命中，委托给底层的 executor 去查询数据库\n list = delegate.query(ms, parameter, rowBounds, resultHandler, key, boundSql);\n // 4. 将结果存入二级缓存（注意：这里只是暂存，需事务提交后才真正生效）\n tcm.putObject(cache, key, list);\n return list;\n }\n // 如果未开启二级缓存，直接委托给底层 executor\n return delegate.query(ms, parameter, rowBounds, resultHandler, key, boundSql);\n}"}],"slateId":"cRqy-nI65CcVg3sdFgQen"}],"slateId":"9RzQKTfHmFSK7-q0erELB"},{"type":"BulletedList","children":[{"type":"ListItem","children":[{"text":"失效时机："}],"slateId":"LiCoze7CmeMsd-9owijRP"}],"slateId":"TYm-Lu-NWEkE5Nkw95i6-"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"X1R8SlXNkxqdTmcBt3dBg","children":[{"text":"mapper实例的增删改方法被调用："}]}],"slateId":"vaRO3g0unTotYv-Cdwrp6"}],"slateId":"pUoY060TYg_IFXvklrPkJ"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"txvYA9AgGDOJnMwdRD-pK","children":[{"text":"当同一个 Mapper（即同一个 Namespace）下执行了 INSERT、UPDATE 或 DELETE 操作时，MyBatis 会清空该 Namespace 下的所有二级缓存。MyBatis 采取的是“全有或全无”的策略。它不会去判断某条具体的更新是否影响了某个具体的查询结果（因为判断成本太高），而是直接清空整个 Mapper 的缓存，以保证下次查询一定能从数据库获取最新数据。"}]}],"slateId":"Yif3HeX6HeatR99dT0D2c"}],"slateId":"z2dSrASlSsIyQExpr08kz"}],"slateId":"tRBQk6NfnaIpvRmaEi00O"},{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"BulletedList","children":[{"type":"ListItem","slateId":"gCOK8beBTHFOzyRg5rN_K","children":[{"text":"flushCache=\"true\"：即使是查询语句（