文章目录

• 前言
• 自定义插件实战
• • 需求
  • 实现过程
  • 测试
  • 总结
• Spring与Mybatis整合
• • 整合过程
  • 实现原理
  • • @MapperScan
    • MapperScannerConfigurer
    • MapperFactoryBean
    • SqlSessionFactoryBean
  • 总结

前言

学习一个框架除了搞清楚核心原理外，还有很关键的需要知道如何去扩展它，而对Mybatis来说，它提供了插件的方式帮助我们进行功能扩展，所以学习如何自定义一个插件也是非常有必要的，本文介绍一个基于插件如何实现一个分表的操作，相信从这个示例的学习，读者会有些收获的。本文还介绍了Spring如何与Mybatis整合的原理，帮助读者更多的了解Mybatis。

自定义插件实战

需求

插件能够改变或者扩展Mybatis的原有的功能，像Mybatis涉及到分页操作，通常就会去引用分页插件来实现分页功能，所以搞懂插件还是非常有必要的。下面通过一个简单的自定义插件来实战一个分片功能，来让读者对插件有更深的了解。

实现过程

首先，自定义一个分片路由插件，通过@Intercepts定义插件的拦截的目标类型，当前插件主要拦截StatementHandler类型，对query、update、prepare方法进行拦截

@Intercepts(
   {
       @Signature(type=StatementHandler.class,method="prepare",args={Connection.class,Integer.class}),
       @Signature(type=StatementHandler.class,method="query",args={Statement.class,ResultHandler.class}),
       @Signature(type=StatementHandler.class,method="update",args={Statement.class})
   }        
)
public class MyRoutePlugin implements Interceptor{
    @Autowired 
    private RouteConfig routeConfig;

    @Autowired
    private DataSource datasouce;
}

同时定义一个分片规则配置类，其中routeKey为分片字段，决定当前执行的SQL语句是否需要分片

@ConfigurationProperties(prefix="route")
@Component
@Data
public class RouteConfg {

    private boolean enabled=true;
    //分片字段
    private String routeKey;
    //分片表的数量
    private int tableCount;
}

接下来，重写intercept方法，定义路由插件的实现逻辑，核心逻辑就是根据StatementHandler一步步通过反射拿到当前执行的SQL语句，然后确认是否开启路由分片，开启之后就会进行后续分片处理

public Object intercept(Invocation invocation) throws Throwable {
        //先判断拦截的目标类型是否为StatementHandler
        if(invocation.getTarget() instanceof StatementHandler){
            //获得具体statementHandler实现，这里拿到的是RoutingStatementHandler
            StatementHandler statementHandler=(StatementHandler) invocation.getTarget();
            //通过RoutingStatementHandler，反射拿到它内部的属性delegate，这个delegate就是具体的statementHandler实现
            Field delegate= getField(statementHandler,"delegate");
            //获得statementHandler实现
            PreparedStatementHandler preparedStatementHandler= (PreparedStatementHandler) delegate.get(statementHandler);
            //拿到boundSql
            BoundSql boundSql= preparedStatementHandler.getBoundSql();
            //拿到它内部sql语句
            Field sqlF=getField(boundSql, "sql");
            String sql=(String) sqlF.get(boundSql);
            if(routeConfig.isEnabled()){
                //处理分片
                return handlerRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
            }
        }
        return invocation.proceed();
    }

//获得实例中指定name的field
public Field getField(Object obj,String fieldName){
    Field field=ReflectionUtils.findField(obj.getClass(), fieldName);
    //设置访问权限
    ReflectionUtils.makeAccessible(field);
    return field;
}

接下来，根据不同的SQL语句类型进行不同分片处理，这里只实现了对查询和插入的分片

//处理路由分片
private Object handlerRoute(String sql, BoundSql boundSql,
            PreparedStatementHandler preparedStatementHandler,Invocation invocation,Field sqlF) throws InvocationTargetException, IllegalAccessException, IllegalArgumentException, SQLException {
        //判断查询类型
        if(sql.contains("select")||sql.contains("SELECT")){
            return hanlderSelectRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
        }
        if(sql.contains("insert")||sql.contains("INSERT")){
            return handlerInsertRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
        }
        return invocation.proceed();
    }

查询的分片处理流程: 先根据执行的SQL语句获得旧的表名，接下来判断是否配置了路由分片字段，如果配置的话，那么会通过当前SQL语句的入参信息，确认SQL语句的查询参数中是否有包含分片字段。如果查询参数满足分片，那么就会根据对应的参数值计算它的hash值，然后基于hash值根据分片表数进行求余，确认分片后的表名，最后通过反射将当前执行的BoundSql中SQL语句替换为新的SQL语句，最终查询就会基于新的SQL语句进行查询，实现了分片效果。

//获得查询语句的表名
private String getSelectName(String sql) {
    String from = sql.substring(sql.indexOf("from") + 4);
    String tableName = from.substring(0, from.indexOf("where")).trim();
    return tableName;
}

//查询语句的路由分片
private Object hanlderSelectRoute(String sql, BoundSql boundSql,
            PreparedStatementHandler preparedStatementHandler, Invocation invocation, Field sqlF) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SQLException {
        //获得表名
        String tableName=getSelectName(sql);
        //从boundSql里面的参数映射中，找到是否有按当前路由分配规则进行分片的字段

        //分场景
        //存在路由分片规则
        if(routeConfig.getRouteKey()!=null){
            Long hashcode=0L;
            List<ParameterMapping> list=boundSql.getParameterMappings();
            for(ParameterMapping bean:list){
                //判断查询的字段是否为分片字段
                if(bean.getProperty().equals(routeConfig.getRouteKey())){
                    hashcode= (long) boundSql.getParameterObject().toString().hashCode();
                    break;
                }
            }
            if(0!=hashcode){
                int tableCount = (int) (hashcode%(long) routeConfig.getTableCount())+1;
                tableName=tableName+tableCount;
                sqlF.set(boundSql, replaceSelectSql(sql,tableName));
                return invocation.proceed();
            }
        }
        //判断是否是prepare方法
        if("prepare".equals(invocation.getMethod().getName())){
            //直接向后传递
            return invocation.proceed();
        }    

        //不按路由分片规则，就需要查所有表来查出数据
        List<Object> result=new ArrayList<Object>();
        for(int i=1;i<=routeConfig.getTableCount();i++){
            //修改它的Statement入参
            Statement statement=getStatement(preparedStatementHandler, sqlF, tableName + i, boundSql, sql);
            //修改它的入参
            invocation.getArgs()[0]=statement;
            //调用结果
            List<Object> tmp=(List<Object>) invocation.proceed();
            if(tmp!=null&&!tmp.isEmpty()){
                result.add(tmp);
            }
        }
        return result;
}

//替换查询语句的表名
private Object replaceSelectSql(String sql, String tableName) {
     String from = sql.substring(0, sql.indexOf("from") + 4);
     String where = sql.substring(sql.indexOf("where"));
     return from + " " + tableName + " " + where;
}

如果当前未配置分片字段或者不满足分片策略时，此时就需要通过所有表来查数据。要查询所有分片表的数据，此时需要调用getStatement方法，为每个表的查询构造一个新的StatementHandler实例，然后再通过新的StatementHandler去查询分片表的数据，最终将查询结果汇总到List集合中并返回。

//创建一个新的StatementHandler
private Statement getStatement(StatementHandler preparedStatementHandler, Field sqlF, String tableName,
            BoundSql boundSql, String sql) throws IllegalArgumentException, IllegalAccessException, SQLException {
        //修改sql语句
        sqlF.set(boundSql, replaceSelectSql(sql, tableName));
        //先获得连接对象
        Connection connection=DataSourceUtils.getConnection(datasouce);
        //获得statementLog
        Log statementLog=getStatementLog(preparedStatementHandler);
        //获得连接日志代理对象
        if (statementLog.isDebugEnabled()) {
            connection= ConnectionLogger.newInstance(connection, statementLog, 1);
         }
        //获得具体StatementHandler
        Statement statement=preparedStatementHandler.prepare(connection, null);
        //参数设置
        preparedStatementHandler.parameterize(statement);
        //返回最终具体的statement实例
        return statement;
}

private Log getStatementLog(StatementHandler preparedStatementHandler) throws IllegalArgumentException, IllegalAccessException {
    Field mp=getField(preparedStatementHandler, "mappedStatement");
    //实例化
    MappedStatement mappedStatement = (MappedStatement) mp.get(preparedStatementHandler);
    return mappedStatement.getStatementLog();
}

插入的分片处理流程，也是类似的，这里就不分析了。

//处理插入的分片
private Object handlerInsertRoute(String sql, BoundSql boundSql,
            PreparedStatementHandler preparedStatementHandler, Invocation invocation,Field sqlF) throws InvocationTargetException, IllegalAccessException {
        if(routeConfig.getRouteKey()!=null){
            Long hashcode=0L;
            List<ParameterMapping> list=boundSql.getParameterMappings();
            for(ParameterMapping bean:list){
                if(bean.getProperty().equals(routeConfig.getRouteKey())){
                    Field field=ReflectionUtils.findField(boundSql.getParameterObject().getClass(), bean.getProperty());
                    //设置访问权限
                    ReflectionUtils.makeAccessible(field);
                    hashcode=(long) field.get(boundSql.getParameterObject()).toString().hashCode();
                    break;
                }
            }
            Long primaryId=hashcode;
            int tableCount = (int) (primaryId%(long) routeConfig.getTableCount())+1;
            //获得表名
            String tableName=getSqlName(sql);
            tableName=tableName+tableCount;
            //修改sql
            sqlF.set(boundSql, replaceSql(sql,tableName));
        }
        return invocation.proceed();
}

//获得新的插入sql语句
private Object replaceSql(String sql,String tableName) {
    //前部分
    String head=sql.substring(0,sql.indexOf("into")+4);
    //后部分
    String low=sql.substring(sql.indexOf("values"));
    return head+" "+tableName+" "+low;
}

//获得插入语句的表名
private String getSqlName(String sql) {
    String tableName=sql.substring(sql.indexOf("into")+4,sql.indexOf("values"));
    if(tableName.contains("(")){
        tableName=tableName.substring(0,tableName.indexOf("("));
    }
    return tableName.trim();
}

测试

定义一个Mapper接口

@Mapper
public interface TUserMapper {

    @Select("select user_id as userId,user_name as userName,seqfrom tb_user where user_id = #{userId}")
    TbUser selectByPrimaryKey(Integer userId);

    @Select("select user_id as userId,user_name as userName,seqfrom tb_user where user_name = #{userName}")
    List<TbUser> selectByUserName(String userName);

    @Insert("insert into tb_user (user_id,user_name,seq) values(#{userId},#{userName},#{seq})")
    void addT_user(TbUser user);
}

数据库中两张分片表

配置文件中指定路由分片策略

route.enabled=true
route.routeKey=userId
route.tableCount=2

第一种情况，向先表中插入10条数据

@Test
public void test5() {
   Random random = new Random();
   for (int i = 1; i < 11; i++) {
      TbUser user = new TbUser();
      user.setUserId((long)random.nextInt(1000));
      user.setUserName("test" + i);
      user.setSeq(i);
      tuserMapper.addT_user(user);
   }
}

从结果可以看到，插入时它会根据userId值进行分片，将数据分别保存到两张表中

第二种情况，指定userId查询一条记录

@Test
public void test7() {
   TbUser tbUser = tuserMapper.selectByPrimaryKey(99);
   System.out.println("tbUser: "+tbUser.toString());
}

从结果可以看到，根据指定userId的值进行了分片，从tb_user1表查到了数据

第三种情况，不通过分片键查询数据

@Test
public void test7() {
    List<TbUser> list=tuserMapper.selectByUserName("test5");
    System.out.println("tbUser: "+list.toString());
}

从结果可以看到，查询了两个表，汇总了结果，并且从tb_user1表中查到了数据

总结

需要明确一点，上述的分片逻辑不是重点，毕竟真正做分库分表的还是需要去引用数据库中间件的。上述示例实现中应该去关注如何一步步进行SQL的改造，以及Mybatis执行过程中一些重要的组件是如何创建的，知道了这些才能对Mybatis有更深的了解。
后续补充一张流程图（需要源码工程的，可以在评论区回复）

Spring与Mybatis整合

整合过程

引入mybatis-spring依赖包

<dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>1.3.1</version>
</dependency>

定义Mybatis的配置类，指定要扫描的Mapper接口包路径，同时指定一个SqlSessionFactoryBean的实例。整合的主要配置就这些，非常简单，但是我们应该关注这些配置背后做的事情。

@Configuration
@MapperScan(basePackages="com.stu",annotationClass=Mapper.class)
public class MybatisConfig {

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(Driver.class.getName());
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/test");
        return dataSource;
    }

    @Bean
    public SqlSessionFactoryBean sessionFactoryBean(@Autowired DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dataSource);
        return sqlSessionFactory;
    }
}

实现原理

@MapperScan

首先，从上面的配置类可以看到它定义了一个@MapperScan注解，这个注解目的向Spring容器中注册了一个Mapper接口的扫描类

@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {

而MapperScan的功能是基于@Import注解定义的属性类MapperScannerRegistrar完成的，由于它实现了ImportBeanDefinitionRegistrar这个Spring的扩展点，因此当该类被Spring解析后就会触发执行registerBeanDefinitions这个方法

public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
     ...
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    //获得mapperscan注解的属性
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
      //向Spring容器中注册Mybatis的扫描类
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }

之后又会执行到registerBeanDefinitions这个核心方法，而这个方法就会将Mapper接口的扫描类MapperScannerConfigurer封装成BeanDefinition对象注册到Spring容器中，到这里@MapperScan注解的功能就完成了。

 //核心： 向Spring注册mybatis的核心组件
 void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
      BeanDefinitionRegistry registry, String beanName) {

    //创建一个类型为MapperScannerConfigurer的BeanDefinition对象
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);

    //获得注解类型： annotationClass = Mapper.class；在Repository包下所有的接口都会带上@Mapper接口
    Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
    if (!Annotation.class.equals(annotationClass)) {
      builder.addPropertyValue("annotationClass", annotationClass);
    }
    ...
    List<String> basePackages = new ArrayList<>();
    basePackages.addAll(
        Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
        .collect(Collectors.toList()));

    basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
        .collect(Collectors.toList()));

    if (basePackages.isEmpty()) {
      basePackages.add(getDefaultBasePackage(annoMeta));
    }
    builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
    //注册
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }
}

MapperScannerConfigurer

这个类的是真正实现扫描Mapper接口的，查看这个类的类图可以发现它实现了BeanDefinitionRegistryPostProcessor这个Spring的扩展点，因此Spring容器启动过程就会先调用该类的postProcessBeanDefinitionRegistry方法

public class MapperScannerConfigurer
    implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
    ....
  //核心方法：扫描指定注解的类，封装成BeanDefinition对象，添加到spring容器中
  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }
    //创建一个mapper扫描器
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);//标识扫描的注解类型
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    //这里注册扫描的接口类型
    scanner.registerFilters();
    //执行扫描
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  } 
}

这个方法中主要创建了一个ClassPathMapperScanner扫描器，而这个扫描器又继承了Spring的ClassPathBeanDefinitionScanner这个扫描器。在执行scan方法扫描时，会先通过ClassPathBeanDefinitionScanner父类扫描器将配置的basePackages包（Mapper接口）路径下所有Mapper接口变成BeanDefinition对象注册到Spring容器中

public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //将basePackages路径下所有Mapper接口，变成BeanDefinition对象注册到Spring容器中
    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 {
      //处理扫描得到的beanDefinitionholder集合，将集合中的每一个mapper接口转换成mapperfactorybean后，注册到spring容器中
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

之后当前ClassPathMapperScanner扫描器又会执行到processBeanDefinitions这个方法，对扫描得到的beanDefinitionholder集合进行处理，将集合中的每一个Mapper接口对应的BeanDefinition对象对应的BeanClass替换为mapperFactoryBeanClass，并为当前BeanDefinition对象的构造函数属性中添加一个以Mapper接口做为入参构造函数（这样当前BeanDefinition对象被实例化时，就会通过该构造函数进行实例化）。最终每一个扫描的Mapper接口注册到Spring容器中，都是对应一个类型为MapperFactoryBean的BeanDefinition对象。

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    GenericBeanDefinition definition;
    for (BeanDefinitionHolder holder : beanDefinitions) {
      definition = (GenericBeanDefinition) holder.getBeanDefinition();
      String beanClassName = definition.getBeanClassName();
      LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
          + "' mapperInterface");

      // the mapper interface is the original class of the bean
      // but, the actual class of the bean is MapperFactoryBean
      //增加一个构造方法，接口类型作为构造函数的入参
      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      //设置当前bean的类型
      definition.setBeanClass(this.mapperFactoryBeanClass);
      definition.getPropertyValues().add("addToConfig", this.addToConfig);

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

MapperFactoryBean

Mapper接口扫描完成后，在应用程序中通过@Autowired注解注入一个Mapper接口时，实际上会注入MapperFactoryBean这个实例，查看MapperFactoryBean类图可以看到它实现了Spring的FactoryBean接口，因此最终注入的会是getObject()方法返回的实例，getObject()方法做的事情就是通过sqlSession获得当前Mapper接口的代理对象，因此最终依赖注入的就是一个Mapper接口的代理对象。

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T>{

    public T getObject() throws Exception {
       //获得mapper的代理对象
       return getSqlSession().getMapper(this.mapperInterface);
    }
}

还有一个关键点，Mybatis为Mapper接口创建代理对象时，需要先向Mybatis的Configuration配置类中注册每一个Mapper接口的代理工厂，之后通过代理工厂才能创建Mapper接口代理对象。而代理工厂的创建是在MapperFactoryBean的checkDaoConfig()方法执行的，触发的时机是由于MapperFactoryBean继承了SqlSessionDaoSupport，该类又继承了DaoSupport,而DaoSupport又实现了InitializingBean接口，当MapperFactoryBean实例化过程就会触发执行afterPropertiesSet方法，然后就会调用到checkDaoConfig()方法，完成为Mapper接口创建代理工厂对象的过程。

/**
   * 由于继承了SqlSessionDaoSupport该类，该类有基础了DaoSupport,而DaoSupport又实现了InitializingBean接口，会触发执行afterPropertiesSet，然后会调用到该方法
   * 建立接口和代理工厂的映射关系
   */
  @Override
  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();
      }
    }
  }

SqlSessionFactoryBean

前面的Mybatis配置类中，可以看到通过@Bean方式注入了一个SqlSessionFactoryBean的实例，而SqlSessionFactoryBean有什么作用呢？查看这个类的类图可以发现它实现了InitializingBean和FactoryBean两个接口。实现InitializingBean接口，那么当前bean被实例化过程中，就会调用到afterPropertiesSet方法，而该方法内部主要调用了buildSqlSessionFactory()方法，在这个buildSqlSessionFactory()方法中，目的就是创建Mybatis中SqlSessionFactory的实例。

public void afterPropertiesSet() throws Exception {
    Assert.notNull(this.dataSource, "Property 'dataSource' is required");
    Assert.notNull(this.sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
    this.sqlSessionFactory = this.buildSqlSessionFactory();
}

而实现FactoryBean接口，那么Spring获取SqlSessionFactoryBean实例时实际上获得的是getObject方法返回的实例，而getObject方法返回的就是前面创建好的SqlSessionFactory这个实例。通过这两个接口就完成了SqlSessionFactory的实例化，并注册到Spring容器中。

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

总结

最后上一张简单时序图

本文到这里就结束了，感谢看到最后的朋友，都看到最后了，点个赞再走啊，如有不对之处还请多多指正。