转载

MyBatis Mapper 代理创建过程

本文主要关注与 SpringBoot 集成时的初始化过程。

1. 核心组件

  • Configuration：MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中。
  • SqlSession：MyBatis 的顶层 API，表示与数据库交互的会话，完成数据库增删改查操作。
  • Executor：执行器是 MyBatis 调度的核心，负责 SQL 语句的生成和查询缓存的维护。
  • StatementHandler：封装了 JDBC Statement 操作，如设置参数等。
  • ParameterHandler：负责将用户传递的参数转换成 JDBC Statement 所对应的数据类型。
  • ResultSetHandler：负责将 JDBC 返回的 ResultSet 结果集转换成 List 类型的集合。
  • TypeHandler：负责将 Java 数据类型和 jdbc 数据类型之间的映射与转换。
  • MapperFactoryBean：与 Spring 集成时表示一个 Mapper 原型的工厂 bean，用以创建最终的代理。
  • MapperProxy：与一个 mapperInterface 对应，维护了 Map<Method, MapperMethod> 映射。
  • MapperAnnotationBuilder：基于注解驱动的 MappedStatement 解析器，解析接口类的每个方法，封装成 MappedStatement。
  • MappedStatement：维护了一条 <select|update|delete|insert> 节点的封装。
  • SqlSource：负责根据用户传递的 parameterObject 动态生成 SQL 语句，将信息封装成 BoundSql 对象。
  • BoundSql：表示动态生成的 SQL 语句以及相应的参数信息。

整体架构如下图：

MyBatis Mapper 代理创建过程

2. 与 SpringBoot 集成的初始化

2.1 概览

SpringBoot 自动组装 MyBatis 的属性（前缀为 “mybatis”）配置成 MybatisProperties 对象。

SpringBoot 的自动配置机制会解析配置类 MybatisAutoConfiguration ，其内部方法定义了两个 Bean 。 

@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {...}

@Bean
@ConditionalOnMissingBean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {...}

在 sqlSessionFactory(dataSource) 方法里利用 MybatisProperties 初始化 SqlSessionFactoryBean ，通过 SqlSessionFactoryBean.buildSqlSessionFactory() 来创建 Configuration ，该方法的主要逻辑是创建并配置 Configuration ，然后用 Configuration 创建 SqlSessionFactory 。

再用 SqlSessionFactory 创建 SqlSessionTemplate 。

SpringBoot 会解析处理配置类上的 @MapperScan("package.to.scan") 注解，调用该注解上的导入类 MapperScannerRegistrar ； MapperScannerRegistrar.registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) 方法创建一个 ClassPathMapperScanner ，利用 @MapperScan 上的信息初始化这个扫描器，以限定扫描的接口范围，对于扫描到的每个 bean 定义，设置其 beanClass 为 MapperFactoryBean ，如果有指定 sqlSessionFactory/sqlSessionTemplate bean 的引用则直接使用，否则采用按类型自动注入。

ClassPathMapperScanner 默认扫描所有的接口并进行注册。

2.2. SqlSessionTemplate

SqlSessionTemplate 是 线程安全、Spring 管理的 SqlSession ，可以注入到其他 Spring 管理的 bean 里去使用。与 Spring 事务管理机制一起工作以保证实际使用的 SqlSession 是与当前的 Spring 事务关联的。另外，它管理着会话的生命周期，包括关闭、提交或回滚会话，基于 Spring 的事务配置。

该模板默认使用 MyBatisExceptionTranslator 把 MyBatis PersistenceExceptions 转换为不受检查的异常 DataAccessExceptions 。

因为 SqlSessionTemplate 是线程安全的，一个实例可以被所有的 DAOs 共享，这样也可以节省点内存。 

public class SqlSessionTemplate implements SqlSession, DisposableBean {
    // 用于创建 SqlSession
    private final SqlSessionFactory sqlSessionFactory;

    // 执行器的类型，默认取 sqlSessionFactory 里的
    private final ExecutorType executorType;

    // 拦截对 SqlSession 接口里声明的方法的调用，以便与 Spring 事务管理集成
    private final SqlSession sqlSessionProxy;

    // 异常转换器
    private final PersistenceExceptionTranslator exceptionTranslator;
}

2.3 Configuration 的构建过程

下面是创建 Configuration 对象的过程： 

// SqlSessionFactoryBean
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configuration != null) {
        configuration = this.configuration;
        if (configuration.getVariables() == null) {
            configuration.setVariables(this.configurationProperties);
        } else if (this.configurationProperties != null) {
            configuration.getVariables().putAll(this.configurationProperties);
        }
    } else if (this.configLocation != null) {
        xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
        configuration = xmlConfigBuilder.getConfiguration();
    } else {
        configuration = new Configuration();
        configuration.setVariables(this.configurationProperties);
    }

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

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

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

    if (hasLength(this.typeAliasesPackage)) {
        String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
        ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        for (String packageToScan : typeAliasPackageArray) {
            configuration.getTypeAliasRegistry().registerAliases(packageToScan,
                typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
        }
    }

    if (!isEmpty(this.typeAliases)) {
        for (Class<?> typeAlias : this.typeAliases) {
            configuration.getTypeAliasRegistry().registerAlias(typeAlias);
        }
    }

    if (!isEmpty(this.plugins)) {
        for (Interceptor plugin : this.plugins) {
            configuration.addInterceptor(plugin);
        }
    }

    if (hasLength(this.typeHandlersPackage)) {
        String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        for (String packageToScan : typeHandlersPackageArray) {
            configuration.getTypeHandlerRegistry().register(packageToScan);
        }
    }

    if (!isEmpty(this.typeHandlers)) {
        for (TypeHandler<?> typeHandler : this.typeHandlers) {
            configuration.getTypeHandlerRegistry().register(typeHandler);
        }
    }

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

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

    if (xmlConfigBuilder != null) {
        try {
            xmlConfigBuilder.parse();
        } catch (Exception ex) {
            throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
        } finally {
            ErrorContext.instance().reset();
        }
    }

    if (this.transactionFactory == null) {
        // 设置事务工厂为 SpringManagedTransactionFactory，以便与 Spring 管理的事务进行协作
        this.transactionFactory = new SpringManagedTransactionFactory();
    }

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

    // 适用于 Mapper 的 XML 文件集中存放的场景
    if (!isEmpty(this.mapperLocations)) {
        // 如果指定了 Mapper 存放的路径则解析
        for (Resource mapperLocation : this.mapperLocations) {
            if (mapperLocation == null) {
                continue;
            }

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

    return this.sqlSessionFactoryBuilder.build(configuration);
}

// SqlSessionFactoryBuilder
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

2.4 Mapper 定义扫描

Mapper 的扫描一是可以通过属性 mybatis.mapperLocations 来指定其存放路径，也可以通过 @MapperScan("package.to.scan") 注解来配置。

该注解扫描指定包下的所有接口、并为其生成代理注册到 Spring 的容器里。

MapperScannerRegistrar 从 @MapperScan 注解获取扫描配置，用以初始化 ClassPathMapperScanner 并完成最终的扫描工作。 

public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);

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

    return beanDefinitions;
}

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
        definition = (GenericBeanDefinition) holder.getBeanDefinition();

        definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59
        // 设置bean定义的类为 MapperFactoryBean
        definition.setBeanClass(this.mapperFactoryBean.getClass());

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

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

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

        if (!explicitFactoryUsed) {
            // 如果没有显式设置 sqlSessionTemplate 或 sqlSessionFactory 则按类型注入
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        }
    }
}

上述代码最重要的是 设置 bean 定义的类为 MapperFactoryBean 。

2.5 Mapper 实例化

Mapper 的 Bean 定义被扫描后会注册到 Spring 容器里，再由 Spring 实例化时调用 MapperFactoryBean.getObject() 方法得到该类型的 Bean 实例，注册到容器里，供应用使用。 

public abstract class SqlSessionDaoSupport extends DaoSupport {
    private SqlSession sqlSession;
    private boolean externalSqlSession;

    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        if (!this.externalSqlSession) {
          this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
        }
    }

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSession = sqlSessionTemplate;
        this.externalSqlSession = true;
    }

    public SqlSession getSqlSession() {
        return this.sqlSession;
    }

    // 省略其他
}

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
    // 该方法在父类的 afterPropertiesSet 里调用
    // 用于把接口类型注册到 Configuration 里。供后面创建代理时使用
    protected void checkDaoConfig() {
        super.checkDaoConfig();

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

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

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

    // 省略其他
}

SqlSessionDaoSupport 的主要作用是把 sqlSession 设置为 SqlSessionTemplate ， DaoSupport 提供了属性设置后回调的初始化钩子，触发调用 MapperFactoryBean.checkDaoConfig 方法。

下面的代理的创建调用链：

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

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

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

// MapperProxyFactory
protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

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

最终创建了一个 JDK 的动态代理，代理的方法处理器为 MapperProxy ，其持有的 SqlSession 仍然是 SqlSessionTemplate 的实例。

欢迎关注我的微信公众号: coderbee笔记 ，可以更及时回复你的讨论。

MyBatis Mapper 代理创建过程
原文  https://coderbee.net/index.php/framework/20191025/2006
正文到此结束
所属分类： Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：635 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日17点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG