Mybatis源码分析（四）mapper接口方法是怎样被调用到的

绝地灬酷狼 2022-02-22 13:04 311阅读 0赞

# 一、问题 #

在Mybatis架构的最上层就是接口层，它定义的是与数据库交互的方式。还记不记得我们在前面章节说的那两种方式？不记得没关系，我们回忆一下。

*  Mybatis提供的API

使用Mybatis提供的API进行操作，通过获取SqlSession对象，然后根据Statement Id 和参数来操作数据库。

String statement = "com.viewscenes.netsupervisor.dao.UserMapper.getUserList";
    List<User> result = sqlsession.selectList(statement);

*  mapper接口

定义Mapper接口，里面定义一系列业务数据操作方法。在Service层通过注入mapper属性，调用其方法就可以执行数据库操作。就像下面这样

public interface UserMapper {    
       List<User> getUserList();
    }
    @Service
    public class UserServiceImpl implements UserService{
       @Autowired
       UserMapper userDao;
       @Override
       public List<User> getUserList() {
           return userDao.getUserList();
       }
    }

那么，问题就来了。UserMapper 只是个接口，并没有任何实现类。那么，我们在调用它的时候，**它是怎样最终执行到我们的SQL语句的呢**？

# 二、扫描 #

1、配置信息

说到这，我们就要看配置文件中的另外一个Bean。通过指定基本包的路径，Mybatis可以通过Spring扫描下面的类，将其注册为BeanDefinition对象。

或者有的朋友项目里还有个annotationClass的属性，即

它的作用就是在扫描的包的时候，会过滤定义的annotationClass。如果有这个注解才会被扫描，通常会在类上以@Repository来标识。不过它的作用也仅是为了过滤而已，我们也完全可以自定义这个注解。比如：

@MyDao
    public interface UserMapper {}
    <property name="annotationClass" value="com.viewscenes.netsupervisor.util.MyDao" />

当然了，如果你确定基本包路径下的所有类都要被注册，那就不必配置annotationClass。

2、扫描基本包

我们来到 `org.mybatis.spring.mapper.MapperScannerConfigurer`这个类，可以看到它实现了几个接口。其中的重点是 `BeanDefinitionRegistryPostProcessor`。它可以 动态的注册Bean信息，方法为 `postProcessBeanDefinitionRegistry()`。

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
       //创建ClassPath扫描器，设置属性，然后调用扫描方法
       ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
       scanner.setAnnotationClass(this.annotationClass);
       scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
       //如果配置了annotationClass，就将其添加到includeFilters
       scanner.registerFilters();
       scanner.scan(this.basePackage);
    }

ClassPathMapperScanner继承自Spring中的类 `ClassPathBeanDefinitionScanner`，所以scan方法会调用到父类的scan方法，而在父类的scan方法中又调用到子类的doScan方法。

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
       public Set<BeanDefinitionHolder> doScan(String... basePackages) {
           //调用Spring的scan方法。就是将基本包下的类注册为BeanDefinition
           Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
           processBeanDefinitions(beanDefinitions);
           return beanDefinitions;
       }
    }

super.doScan(basePackages)是Spring中的方法。我们在Spring系列文章中已经详细分析了，在这里就不细究。主要看它返回的是BeanDefinition的集合。

3、配置BeanDefinition

上面已经扫描到了所有的Mapper接口，并将其注册为BeanDefinition对象。接下来调用 `processBeanDefinitions()`要配置这些BeanDefinition对象。

public class ClassPathMapperScanner extends ClassPathBeanDefinitionScanner {
       private MapperFactoryBean<?> mapperFactoryBean = new MapperFactoryBean<Object>();
       private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
           GenericBeanDefinition definition;
           for (BeanDefinitionHolder holder : beanDefinitions) {
               definition = (GenericBeanDefinition) holder.getBeanDefinition();
               //将mapper接口的名称添加到构造参数   definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName());
               //设置BeanDefinition的class
               definition.setBeanClass(this.mapperFactoryBean.getClass());
               //添加属性addToConfig
               definition.getPropertyValues().add("addToConfig", this.addToConfig);
               //添加属性sqlSessionFactory
               definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
               ......
       }
    }

处理的过程很简单，就是往BeanDefinition对象中设置了一些属性。我们重点关注两个。

*  设置beanClass

设置BeanDefinition对象的BeanClass为 `MapperFactoryBean<?>`。这意味着什么呢？以UserMapper为例，意味着当前的mapper接口在Spring容器中，beanName是userMapper，beanClass是MapperFactoryBean.class。那么在IOC初始化的时候，实例化的对象就是MapperFactoryBean对象。

*  设置sqlSessionFactory属性

为BeanDefinition对象添加属性sqlSessionFactory，这就意味着，在为BeanDefinition对象设置PropertyValue的时候，会调用到 `setSqlSessionFactory()`。

# 三、创建SqlSession的代理 #

上面我们说在为BeanDefinition对象设置PropertyValue的时候，会调用它的setSqlSessionFactory，我们来看这个方法。

首先，这里说的BeanDefinition对象就是beanClass为MapperFactoryBean.class的MapperFactoryBean对象。定位到这个类，我们发现它继承自 `org.mybatis.spring.support.SqlSessionDaoSupport`。

public abstract class SqlSessionDaoSupport extends DaoSupport {
       private SqlSession sqlSession;
       public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
           if (!this.externalSqlSession) {
               this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
           }
       }
    }

在它的setSqlSessionFactory方法里，最终调用的是new SqlSessionTemplate()。所以sqlSession的对象其实是一个SqlSessionTemplate的实例。我们来看它的构造函数。

public class SqlSessionTemplate implements SqlSession, DisposableBean {
       public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
                           PersistenceExceptionTranslator exceptionTranslator) {
           //设置sqlSessionFactory
           this.sqlSessionFactory = sqlSessionFactory;
           //设置执行器的类型
           this.executorType = executorType;
           //异常相关处理类
           this.exceptionTranslator = exceptionTranslator;
           //sqlSession的代理
           this.sqlSessionProxy = (SqlSession) newProxyInstance(
           SqlSessionFactory.class.getClassLoader(),
           new Class[] { SqlSession.class },
           new SqlSessionInterceptor());
       }
    }

对JDK动态代理熟悉的朋友，一定会先看到 `newProxyInstance`。它是给sqlSession接口创建了一个代理类，这个代理类的处理器程序就是 `SqlSessionInterceptor()`。不用多说，SqlSessionInterceptor肯定实现了InvocationHandler接口。 这就意味着，当调用到sqlSession的时候，实际执行的它的代理类，代理类又会调用到处理器程序的invoke()方法。

private class SqlSessionInterceptor implements InvocationHandler {
       public Object invoke(Object proxy, Method method, Object[] args){
           //内容先略过不看
       }
    }

最终在 `setSqlSessionFactory`这个方法里，sqlSession获取到的是SqlSessionTemplate实例。而在SqlSessionTemplate对象中，主要包含sqlSessionFactory和sqlSessionProxy，而sqlSessionProxy实际上是SqlSession接口的代理对象。

![20190409133018247.png][]

# 四、创建Mapper接口的代理 #

上面我们说到MapperFactoryBean继承自SqlSessionDaoSupport，还有一点没说的是，它同时实现了FactoryBean接口。

这就说明，MapperFactoryBean不是一个纯粹的人。啊不对，不是一个纯粹的Bean，而是一个工厂Bean。如果要声明一个Bean为工厂Bean，它要实现FactoryBean接口，这个接口就三个方法。

public interface FactoryBean<T> {
       //返回对象的实例
       T getObject() throws Exception;
       //返回对象实例的类型
       Class<?> getObjectType();
       //是否为单例
       boolean isSingleton();
    }

MapperFactoryBean既然是一个工厂Bean，那么它返回就不是这个对象的本身，而是这个对象getObjectType方法返回的实例。为什么会这样呢？ 在Spring中执行getBean的时候，在创建完Bean对象且完成依赖注入之后，用调用到 `bean=getObjectForBeanInstance(sharedInstance,name,beanName,mbd);`。 这个方法会判断当前Bean是否为FactoryBean，如果不是就不再执行，如果是最终就会调用到它的getObject()方法。

protected Object getObjectForBeanInstance(
               Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
       if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
           return beanInstance;
       }
       //getObjectFromFactoryBean最终调用的是getObject
       Object object = getObjectFromFactoryBean(factory, beanName, !synthetic);
       return object;
    }

说了这么多，就是怕有的朋友对工厂Bean不了解，看这块内容的时候会比较迷惑。那么，getObject究竟会返回什么对象呢？

1、getObject()

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
       public T getObject() throws Exception {
           //mapperInterface是mapper接口的对象
           return getSqlSession().getMapper(this.mapperInterface);
       }
    }

getSqlSession()我们已经分析完了，它返回的就是SqlSessionTemplate对象的实例。所以，我们主要看getMapper()。

2、getMapper

public class MapperRegistry {
       public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
           final MapperProxyFactory<T> mapperProxyFactory = knownMappers.get(type);
           return mapperProxyFactory.newInstance(sqlSession);  
       }
    }

我们看到，它实现比较简单。不过，有个问题是 `knownMappers`是从哪儿来的呢？它为什么可以根据type接口就能获取到 `MapperProxyFactory`实例呢？

是否还记得，在扫描注解式SQL声明的时候，它调用到addMapper方法，其实就是这个类。

public class MapperRegistry {
       public <T> void addMapper(Class<T> type) {
           if (type.isInterface()) {
               try {
                   /注入type接口的映射
                   knownMappers.put(type, new MapperProxyFactory<T>(type));
                   //扫描注解
                   MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
                   parser.parse();
               }
           }
       }
    }

这也就解释了为什么 `knownMappers.get(type)`就能获取到MapperProxyFactory的实例，下面来看它内部到底创建了什么对象并返回的。

3、newInstance

在创建过程中，实际返回的是一个代理类，即mapper接口的代理类。

public class MapperProxyFactory<T> {
       public T newInstance(SqlSession sqlSession) {
           //mapperProxy就是一个调用程序处理器,显然它要实现InvocationHandler接口
           final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
           //JDK动态代理，生成的就是mapperInterface接口的代理类
           //mapperInterface就是我们的mapper接口
           //比如com.viewscenes.netsupervisor.dao.UserMapper
           return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(),
                   new Class[] { mapperInterface }, mapperProxy);
       }
    }

public class MapperProxy<T> implements InvocationHandler {
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           //具体流程先略过....
           return method.invoke(this, args);
       }
    }

看到这里，我们都已经明白了。getObject方法返回的就是mapper接口的代理类。换言之，每一个mapper接口对应的都是自身的接口代理。那么，在实际调用到mapper方法的时候，就会调用到调用程序处理器的 MapperProxy.invoke(Objectproxy,Methodmethod,Object[]args)。

# 五、总结 #

本章节重要阐述了Mapper接口的代理创建过程。我们简单梳理下流程：

*  扫描mapper接口基本包，将为注册为BeanDefinition对象。
 *  设置BeanDefinition的对象的beanClass和sqlSessionFactory属性。
 *  设置sqlSessionFactory属性的时候，调用SqlSessionTemplate的构造方法，创建SqlSession接口的代理类。
 *  获取BeanDefinition对象的时候，调用其工厂方法getObject，返回mapper接口的代理类。

最后我们在Service层，通过 `@AutowiredUserMapperuserDao`注入属性的时候，返回的就是代理类。执行userDao的方法的时候，实际调用的是代理类的invoke方法。 最后的最后，我们看一下这个代理类长什么样子。 ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3czNzI0MjYwOTY_size_16_color_FFFFFF_t_70][]

[20190409133018247.png]: /images/20220222/5c46c5c164af48fe858b723a28fa7809.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3czNzI0MjYwOTY_size_16_color_FFFFFF_t_70]: /images/20220222/700e93f784e74210865def1e4f4f082d.png