文章目錄

• 前言
• 自定義插件實(shí)戰(zhàn)
• • 需求
  • 實(shí)現(xiàn)過(guò)程
  • 測(cè)試
  • 總結(jié)
• Spring與Mybatis整合
• • 整合過(guò)程
  • 實(shí)現(xiàn)原理
  • • @MapperScan
    • MapperScannerConfigurer
    • MapperFactoryBean
    • SqlSessionFactoryBean
  • 總結(jié)

前言

學(xué)習(xí)一個(gè)框架除了搞清楚核心原理外，還有很關(guān)鍵的需要知道如何去擴(kuò)展它，而對(duì)Mybatis來(lái)說(shuō)，它提供了插件的方式幫助我們進(jìn)行功能擴(kuò)展，所以學(xué)習(xí)如何自定義一個(gè)插件也是非常有必要的，本文介紹一個(gè)基于插件如何實(shí)現(xiàn)一個(gè)分表的操作，相信從這個(gè)示例的學(xué)習(xí)，讀者會(huì)有些收獲的。本文還介紹了Spring如何與Mybatis整合的原理，幫助讀者更多的了解Mybatis。

自定義插件實(shí)戰(zhàn)

需求

插件能夠改變或者擴(kuò)展Mybatis的原有的功能，像Mybatis涉及到分頁(yè)操作，通常就會(huì)去引用分頁(yè)插件來(lái)實(shí)現(xiàn)分頁(yè)功能，所以搞懂插件還是非常有必要的。下面通過(guò)一個(gè)簡(jiǎn)單的自定義插件來(lái)實(shí)戰(zhàn)一個(gè)分片功能，來(lái)讓讀者對(duì)插件有更深的了解。

實(shí)現(xiàn)過(guò)程

首先，自定義一個(gè)分片路由插件，通過(guò)@Intercepts定義插件的攔截的目標(biāo)類型，當(dāng)前插件主要攔截StatementHandler類型，對(duì)query、update、prepare方法進(jìn)行攔截

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

同時(shí)定義一個(gè)分片規(guī)則配置類，其中routeKey為分片字段，決定當(dāng)前執(zhí)行的SQL語(yǔ)句是否需要分片

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

    private boolean enabled=true;
    //分片字段
    private String routeKey;
    //分片表的數(shù)量
    private int tableCount;
}

接下來(lái)，重寫(xiě)intercept方法，定義路由插件的實(shí)現(xiàn)邏輯，核心邏輯就是根據(jù)StatementHandler一步步通過(guò)反射拿到當(dāng)前執(zhí)行的SQL語(yǔ)句，然后確認(rèn)是否開(kāi)啟路由分片，開(kāi)啟之后就會(huì)進(jìn)行后續(xù)分片處理

public Object intercept(Invocation invocation) throws Throwable {
        //先判斷攔截的目標(biāo)類型是否為StatementHandler
        if(invocation.getTarget() instanceof StatementHandler){
            //獲得具體statementHandler實(shí)現(xiàn)，這里拿到的是RoutingStatementHandler
            StatementHandler statementHandler=(StatementHandler) invocation.getTarget();
            //通過(guò)RoutingStatementHandler，反射拿到它內(nèi)部的屬性delegate，這個(gè)delegate就是具體的statementHandler實(shí)現(xiàn)
            Field delegate= getField(statementHandler,"delegate");
            //獲得statementHandler實(shí)現(xiàn)
            PreparedStatementHandler preparedStatementHandler= (PreparedStatementHandler) delegate.get(statementHandler);
            //拿到boundSql
            BoundSql boundSql= preparedStatementHandler.getBoundSql();
            //拿到它內(nèi)部sql語(yǔ)句
            Field sqlF=getField(boundSql, "sql");
            String sql=(String) sqlF.get(boundSql);
            if(routeConfig.isEnabled()){
                //處理分片
                return handlerRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
            }
        }
        return invocation.proceed();
    }

//獲得實(shí)例中指定name的field
public Field getField(Object obj,String fieldName){
    Field field=ReflectionUtils.findField(obj.getClass(), fieldName);
    //設(shè)置訪問(wèn)權(quán)限
    ReflectionUtils.makeAccessible(field);
    return field;
}

接下來(lái)，根據(jù)不同的SQL語(yǔ)句類型進(jìn)行不同分片處理，這里只實(shí)現(xiàn)了對(duì)查詢和插入的分片

//處理路由分片
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();
    }

查詢的分片處理流程: 先根據(jù)執(zhí)行的SQL語(yǔ)句獲得舊的表名，接下來(lái)判斷是否配置了路由分片字段，如果配置的話，那么會(huì)通過(guò)當(dāng)前SQL語(yǔ)句的入?yún)⑿畔?，確認(rèn)SQL語(yǔ)句的查詢參數(shù)中是否有包含分片字段。如果查詢參數(shù)滿足分片，那么就會(huì)根據(jù)對(duì)應(yīng)的參數(shù)值計(jì)算它的hash值，然后基于hash值根據(jù)分片表數(shù)進(jìn)行求余，確認(rèn)分片后的表名，最后通過(guò)反射將當(dāng)前執(zhí)行的BoundSql中SQL語(yǔ)句替換為新的SQL語(yǔ)句，最終查詢就會(huì)基于新的SQL語(yǔ)句進(jìn)行查詢，實(shí)現(xiàn)了分片效果。

//獲得查詢語(yǔ)句的表名
private String getSelectName(String sql) {
    String from = sql.substring(sql.indexOf("from") + 4);
    String tableName = from.substring(0, from.indexOf("where")).trim();
    return tableName;
}

//查詢語(yǔ)句的路由分片
private Object hanlderSelectRoute(String sql, BoundSql boundSql,
            PreparedStatementHandler preparedStatementHandler, Invocation invocation, Field sqlF) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SQLException {
        //獲得表名
        String tableName=getSelectName(sql);
        //從boundSql里面的參數(shù)映射中，找到是否有按當(dāng)前路由分配規(guī)則進(jìn)行分片的字段

        //分場(chǎng)景
        //存在路由分片規(guī)則
        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();
        }    

        //不按路由分片規(guī)則，就需要查所有表來(lái)查出數(shù)據(jù)
        List<Object> result=new ArrayList<Object>();
        for(int i=1;i<=routeConfig.getTableCount();i++){
            //修改它的Statement入?yún)?            Statement statement=getStatement(preparedStatementHandler, sqlF, tableName + i, boundSql, sql);
            //修改它的入?yún)?            invocation.getArgs()[0]=statement;
            //調(diào)用結(jié)果
            List<Object> tmp=(List<Object>) invocation.proceed();
            if(tmp!=null&&!tmp.isEmpty()){
                result.add(tmp);
            }
        }
        return result;
}

//替換查詢語(yǔ)句的表名
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;
}

如果當(dāng)前未配置分片字段或者不滿足分片策略時(shí)，此時(shí)就需要通過(guò)所有表來(lái)查數(shù)據(jù)。要查詢所有分片表的數(shù)據(jù)，此時(shí)需要調(diào)用getStatement方法，為每個(gè)表的查詢構(gòu)造一個(gè)新的StatementHandler實(shí)例，然后再通過(guò)新的StatementHandler去查詢分片表的數(shù)據(jù)，最終將查詢結(jié)果匯總到List集合中并返回。

//創(chuàng)建一個(gè)新的StatementHandler
private Statement getStatement(StatementHandler preparedStatementHandler, Field sqlF, String tableName,
            BoundSql boundSql, String sql) throws IllegalArgumentException, IllegalAccessException, SQLException {
        //修改sql語(yǔ)句
        sqlF.set(boundSql, replaceSelectSql(sql, tableName));
        //先獲得連接對(duì)象
        Connection connection=DataSourceUtils.getConnection(datasouce);
        //獲得statementLog
        Log statementLog=getStatementLog(preparedStatementHandler);
        //獲得連接日志代理對(duì)象
        if (statementLog.isDebugEnabled()) {
            connection= ConnectionLogger.newInstance(connection, statementLog, 1);
         }
        //獲得具體StatementHandler
        Statement statement=preparedStatementHandler.prepare(connection, null);
        //參數(shù)設(shè)置
        preparedStatementHandler.parameterize(statement);
        //返回最終具體的statement實(shí)例
        return statement;
}

private Log getStatementLog(StatementHandler preparedStatementHandler) throws IllegalArgumentException, IllegalAccessException {
    Field mp=getField(preparedStatementHandler, "mappedStatement");
    //實(shí)例化
    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());
                    //設(shè)置訪問(wèn)權(quán)限
                    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語(yǔ)句
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;
}

//獲得插入語(yǔ)句的表名
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();
}

測(cè)試

定義一個(gè)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);
}

數(shù)據(jù)庫(kù)中兩張分片表

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

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

第一種情況，向先表中插入10條數(shù)據(jù)

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

從結(jié)果可以看到，插入時(shí)它會(huì)根據(jù)userId值進(jìn)行分片，將數(shù)據(jù)分別保存到兩張表中

第二種情況，指定userId查詢一條記錄

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

從結(jié)果可以看到，根據(jù)指定userId的值進(jìn)行了分片，從tb_user1表查到了數(shù)據(jù)

第三種情況，不通過(guò)分片鍵查詢數(shù)據(jù)

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

從結(jié)果可以看到，查詢了兩個(gè)表，匯總了結(jié)果，并且從tb_user1表中查到了數(shù)據(jù)

總結(jié)

需要明確一點(diǎn)，上述的分片邏輯不是重點(diǎn)，畢竟真正做分庫(kù)分表的還是需要去引用數(shù)據(jù)庫(kù)中間件的。上述示例實(shí)現(xiàn)中應(yīng)該去關(guān)注如何一步步進(jìn)行SQL的改造，以及Mybatis執(zhí)行過(guò)程中一些重要的組件是如何創(chuàng)建的，知道了這些才能對(duì)Mybatis有更深的了解。
后續(xù)補(bǔ)充一張流程圖（需要源碼工程的，可以在評(píng)論區(qū)回復(fù)）

Spring與Mybatis整合

整合過(guò)程

引入mybatis-spring依賴包

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

定義Mybatis的配置類，指定要掃描的Mapper接口包路徑，同時(shí)指定一個(gè)SqlSessionFactoryBean的實(shí)例。整合的主要配置就這些，非常簡(jiǎn)單，但是我們應(yīng)該關(guān)注這些配置背后做的事情。

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

實(shí)現(xiàn)原理

@MapperScan

首先，從上面的配置類可以看到它定義了一個(gè)@MapperScan注解，這個(gè)注解目的向Spring容器中注冊(cè)了一個(gè)Mapper接口的掃描類

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

而MapperScan的功能是基于@Import注解定義的屬性類MapperScannerRegistrar完成的，由于它實(shí)現(xiàn)了ImportBeanDefinitionRegistrar這個(gè)Spring的擴(kuò)展點(diǎn)，因此當(dāng)該類被Spring解析后就會(huì)觸發(fā)執(zhí)行registerBeanDefinitions這個(gè)方法

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容器中注冊(cè)Mybatis的掃描類
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }

之后又會(huì)執(zhí)行到registerBeanDefinitions這個(gè)核心方法，而這個(gè)方法就會(huì)將Mapper接口的掃描類MapperScannerConfigurer封裝成BeanDefinition對(duì)象注冊(cè)到Spring容器中，到這里@MapperScan注解的功能就完成了。

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

    //創(chuàng)建一個(gè)類型為MapperScannerConfigurer的BeanDefinition對(duì)象
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
    builder.addPropertyValue("processPropertyPlaceHolders", true);

    //獲得注解類型： annotationClass = Mapper.class；在Repository包下所有的接口都會(huì)帶上@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));
    //注冊(cè)
    registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

  }
}

MapperScannerConfigurer

這個(gè)類的是真正實(shí)現(xiàn)掃描Mapper接口的，查看這個(gè)類的類圖可以發(fā)現(xiàn)它實(shí)現(xiàn)了BeanDefinitionRegistryPostProcessor這個(gè)Spring的擴(kuò)展點(diǎn)，因此Spring容器啟動(dòng)過(guò)程就會(huì)先調(diào)用該類的postProcessBeanDefinitionRegistry方法

public class MapperScannerConfigurer
    implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
    ....
  //核心方法：掃描指定注解的類，封裝成BeanDefinition對(duì)象，添加到spring容器中
  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }
    //創(chuàng)建一個(gè)mapper掃描器
    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);//標(biāo)識(shí)掃描的注解類型
    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));
    }
    //這里注冊(cè)掃描的接口類型
    scanner.registerFilters();
    //執(zhí)行掃描
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  } 
}

這個(gè)方法中主要?jiǎng)?chuàng)建了一個(gè)ClassPathMapperScanner掃描器，而這個(gè)掃描器又繼承了Spring的ClassPathBeanDefinitionScanner這個(gè)掃描器。在執(zhí)行scan方法掃描時(shí)，會(huì)先通過(guò)ClassPathBeanDefinitionScanner父類掃描器將配置的basePackages包（Mapper接口）路徑下所有Mapper接口變成BeanDefinition對(duì)象注冊(cè)到Spring容器中

public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    //將basePackages路徑下所有Mapper接口，變成BeanDefinition對(duì)象注冊(cè)到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集合，將集合中的每一個(gè)mapper接口轉(zhuǎn)換成mapperfactorybean后，注冊(cè)到spring容器中
      processBeanDefinitions(beanDefinitions);
    }

    return beanDefinitions;
  }

之后當(dāng)前ClassPathMapperScanner掃描器又會(huì)執(zhí)行到processBeanDefinitions這個(gè)方法，對(duì)掃描得到的beanDefinitionholder集合進(jìn)行處理，將集合中的每一個(gè)Mapper接口對(duì)應(yīng)的BeanDefinition對(duì)象對(duì)應(yīng)的BeanClass替換為mapperFactoryBeanClass，并為當(dāng)前BeanDefinition對(duì)象的構(gòu)造函數(shù)屬性中添加一個(gè)以Mapper接口做為入?yún)?gòu)造函數(shù)（這樣當(dāng)前BeanDefinition對(duì)象被實(shí)例化時(shí)，就會(huì)通過(guò)該構(gòu)造函數(shù)進(jìn)行實(shí)例化）。最終每一個(gè)掃描的Mapper接口注冊(cè)到Spring容器中，都是對(duì)應(yīng)一個(gè)類型為MapperFactoryBean的BeanDefinition對(duì)象。

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
      //增加一個(gè)構(gòu)造方法，接口類型作為構(gòu)造函數(shù)的入?yún)?      definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
      //設(shè)置當(dāng)前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接口掃描完成后，在應(yīng)用程序中通過(guò)@Autowired注解注入一個(gè)Mapper接口時(shí)，實(shí)際上會(huì)注入MapperFactoryBean這個(gè)實(shí)例，查看MapperFactoryBean類圖可以看到它實(shí)現(xiàn)了Spring的FactoryBean接口，因此最終注入的會(huì)是getObject()方法返回的實(shí)例，getObject()方法做的事情就是通過(guò)sqlSession獲得當(dāng)前Mapper接口的代理對(duì)象，因此最終依賴注入的就是一個(gè)Mapper接口的代理對(duì)象。

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

    public T getObject() throws Exception {
       //獲得mapper的代理對(duì)象
       return getSqlSession().getMapper(this.mapperInterface);
    }
}

還有一個(gè)關(guān)鍵點(diǎn)，Mybatis為Mapper接口創(chuàng)建代理對(duì)象時(shí)，需要先向Mybatis的Configuration配置類中注冊(cè)每一個(gè)Mapper接口的代理工廠，之后通過(guò)代理工廠才能創(chuàng)建Mapper接口代理對(duì)象。而代理工廠的創(chuàng)建是在MapperFactoryBean的checkDaoConfig()方法執(zhí)行的，觸發(fā)的時(shí)機(jī)是由于MapperFactoryBean繼承了SqlSessionDaoSupport，該類又繼承了DaoSupport,而DaoSupport又實(shí)現(xiàn)了InitializingBean接口，當(dāng)MapperFactoryBean實(shí)例化過(guò)程就會(huì)觸發(fā)執(zhí)行afterPropertiesSet方法，然后就會(huì)調(diào)用到checkDaoConfig()方法，完成為Mapper接口創(chuàng)建代理工廠對(duì)象的過(guò)程。

/**
   * 由于繼承了SqlSessionDaoSupport該類，該類有基礎(chǔ)了DaoSupport,而DaoSupport又實(shí)現(xiàn)了InitializingBean接口，會(huì)觸發(fā)執(zhí)行afterPropertiesSet，然后會(huì)調(diào)用到該方法
   * 建立接口和代理工廠的映射關(guān)系
   */
  @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 {
        //為當(dāng)前接口添加代理工廠對(duì)象
        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配置類中，可以看到通過(guò)@Bean方式注入了一個(gè)SqlSessionFactoryBean的實(shí)例，而SqlSessionFactoryBean有什么作用呢？查看這個(gè)類的類圖可以發(fā)現(xiàn)它實(shí)現(xiàn)了InitializingBean和FactoryBean兩個(gè)接口。實(shí)現(xiàn)InitializingBean接口，那么當(dāng)前bean被實(shí)例化過(guò)程中，就會(huì)調(diào)用到afterPropertiesSet方法，而該方法內(nèi)部主要調(diào)用了buildSqlSessionFactory()方法，在這個(gè)buildSqlSessionFactory()方法中，目的就是創(chuàng)建Mybatis中SqlSessionFactory的實(shí)例。

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

而實(shí)現(xiàn)FactoryBean接口，那么Spring獲取SqlSessionFactoryBean實(shí)例時(shí)實(shí)際上獲得的是getObject方法返回的實(shí)例，而getObject方法返回的就是前面創(chuàng)建好的SqlSessionFactory這個(gè)實(shí)例。通過(guò)這兩個(gè)接口就完成了SqlSessionFactory的實(shí)例化，并注冊(cè)到Spring容器中。

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

總結(jié)

最后上一張簡(jiǎn)單時(shí)序圖

本文到這里就結(jié)束了，感謝看到最后的朋友，都看到最后了，點(diǎn)個(gè)贊再走啊，如有不對(duì)之處還請(qǐng)多多指正。