Mybatis源码解析(三) —— Mapper代理类的生成

时间:2021-03-26 06:17:08

Mybatis源码解析(三) —— Mapper代理类的生成

  在本系列第一篇文章已经讲述过在Mybatis-Spring项目中,是通过 MapperFactoryBean 的 getObject()方法来获取到Mapper的代理类并注入到Spring容器中的。在学习本章之前我们先提出以下几点问题:

  • 1、 Mapper接口是如何被加载 到 Configuration 中的?

  • 2、 Mapper代理类是如何生成的?

  • 3、 Mapper代理类是如何实现接口方法的?

   本章内容就是围绕着上面三个问题进行解析,那么带着问题去看源码吧!

一、加载 Mapper接口

  针对Mybatis项目,Mapper的配置加载是从XmlConfigBuilder.mapperElement()方法中触发的。我们来看下源码:

  private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) {
// 通过 package 形式加载 ,内部其实也是获取到 package 路径下的所有class再通过 class 形式加载
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else {
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
if (resource != null && url == null && mapperClass == null) {
// 加载 Mapper.xml 的
ErrorContext.instance().resource(resource);
InputStream inputStream = Resources.getResourceAsStream(resource);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();
} else if (resource == null && url != null && mapperClass == null) {
// 加载 Mapper.xml 的
ErrorContext.instance().resource(url);
InputStream inputStream = Resources.getUrlAsStream(url);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
mapperParser.parse();
} else if (resource == null && url == null && mapperClass != null) {
// 通过 class 形式加载
Class<?> mapperInterface = Resources.classForName(mapperClass);
configuration.addMapper(mapperInterface);
} else {
throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
}
}
}
}
}

从上面源码看,加载Mapper接口有2种形式: 一种是根据设置的 package 找到路径下面所有的class并通过configuration.addMapper() 加载。 另一种是根据指定设置的Mapper接口路径直接通过 configuration.addMapper()加载class。所以加载Mapper接口最终都是 configuration.addMapper() 来加载的。

  而针对Mybatis-Spring项目则是 获取 MapperScannerConfigurer 的 basePackage 参数,并通过 ClassPathMapperScanner 扫描到 设置的 basePackage 路径下的所有class ,并得到 BeanDefinition ,后面的情况在第一篇文章已经讲过,最终是得到了 MapperFactoryBean ,并且还到了 MapperFactoryBean 内部的 checkDaoConfig() 方法加载Mapper接口的内容,那么我们再次回顾下这个方法的源码:


@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 {
// 最终都是通过 addMapper() 方法加载的。
configuration.addMapper(this.mapperInterface);
} catch (Throwable t) {
logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", t);
throw new IllegalArgumentException(t);
} finally {
ErrorContext.instance().reset();
}
}
}

   从源码中我们发现 内部其实还是通过 configuration.addMapper() 加载的。可能有些同学会问,checkDaoConfig()什么时候被调用的,这个可以追溯到 MapperFactoryBean 的继承关系图,可以发现实现了 InitializingBean接口, 而 checkDaoConfig() 就是 通过afterPropertiesSet() 调用的。所以在MapperFactoryBean 初始化创建的时候就会调用checkDaoConfig(),即 加载Mapper接口。

   根据上面的分析,我们可以发现 configuration.addMapper() 是实现加载Mapper接口的最核心的方法,那么我们就来好好分析下这个方法内部实现源码:


public <T> void addMapper(Class<T> type) {
mapperRegistry.addMapper(type);
}

  其内部是通过 委托 mapperRegistry 来就行加载的,那继续往下看:


public <T> void addMapper(Class<T> type) {
// 1、 判断是否为接口
if (type.isInterface()) {
// 2、 判断是否已加载
if (hasMapper(type)) {
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
boolean loadCompleted = false;
try {
// 3、 将 Mapper的class作为 MapperProxyFactory(生成Mapper代理对象的工厂类) 的构参,并保存到 knownMappers 中。
knownMappers.put(type, new MapperProxyFactory<T>(type));
// 4、 解析 Class对象中,包含的所有mybatis框架中定义的注解,并生成Cache、ResultMap、MappedStatement。
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
parser.parse();
loadCompleted = true;
} finally {
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}

   根据源码可以把整个加载流程分4个步骤:

  • 1、 判断是否为接口

  • 2、 判断是否已加载

  • 3、 将 Mapper的class作为 MapperProxyFactory(生成Mapper代理对象的工厂类) 的构参,并保存到 knownMappers 中。

  • 4、 解析 Class对象中,包含的所有mybatis框架中定义的注解,并生成Cache、ResultMap、MappedStatement。

   其中第三步是加载Mapper的核心,也就是同创建了一个生成Mapper代理对象的工厂对象,并将其放到map,等需要创建Mapper代理对象的是再通过获取map中的工厂对象即可。 关于第四步,就是最近几年比较流行的通过注解编写SQl形式的解析方法。我们知道mybatis支持xml和注解形式的Sql编写。所以 MapperAnnotationBuilder 就是解析注解形式,根解析xml一样, 最终也会生成 ResultMap、MappedStatement对象封装到 configuration 中。关于它是如何解析的,有兴趣的同学可以看啊可能源码,这里不在描述。

二、 Mapper动态代理对象(MapperProxy)的创建

   通过之前的文章,我们知道 MapperFactoryBean 实现了 FactoryBean,也就是说在Spring 根据BeanDefinition 加载Bean的时候会调用 MapperFactoryBean.getObject() 获取真实的Bean并注入到容器中。不用想,getObject()获取到的一定是Mapper接口的代理实现类 MapperProxy,那么我们来一步步分析是如何创建 MapperProxy


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

   getObject()方法是通过 getSqlSession().getMapper() 获取到 MapperProxy 的,相信大家对这个不陌生吧。至于这里的SqlSession 其实是 SqlSessionTemplate ,这个之前也讲过,所以继续查看:


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

   最终还是通过 configuration().getMapper() 获取到 MapperProxy。继续查看:


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

   毫不意外的肯定是委托 mapperRegistry.getMapper() 来获取,继续查看:


public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// 1、 从 knownMappers 中获取到 MapperProxyFactory
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null)
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
try {
// 2、 通过 mapperProxyFactory.newInstance() 创建 MapperProxy
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}

   也毫不意外的是 从 knownMappers 中获取到 MapperProxyFactory ,再 通过 mapperProxyFactory.newInstance() 创建 MapperProxy。 继续查看 mapperProxyFactory.newInstance() 内部实现:


@SuppressWarnings("unchecked")
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);
}

   从上面源码可以清晰的看到 Proxy.newProxyInstance() 指定了被代理的类是 mapperInterface,其代理类是 mapperProxy,所以最终动态创建出 mapperInterface 的动态代理类 MapperProxy@xxxx (动态代理类名)

三、 MapperProxy 接口方法的实现

  通过上面的解析,我们明确了 MapperProxy 代理是通过JDK动态生成,但接口方法是如何实现的呢? 这里就得看 MapperProxy 源码:


public class MapperProxy<T> implements InvocationHandler, Serializable { private static final long serialVersionUID = -6424540398559729838L;
// 注意: 这个 SqlSession 实际上是 SqlSessionTemplate
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache; public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
} public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 如果调用的方法是 Object 种定义的方法,直接执行
if (Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
// 接口方法的调用都是通过 MapperMethod 来执行的
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
} // Mapper接口的每个方法 都会生成一个 MapperMethod 对象,并通过 methodCache 来维护它们之间的关系
private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = methodCache.get(method);
if (mapperMethod == null) {
// 注意这里 传入了 要执行的 方法信息
mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
methodCache.put(method, mapperMethod);
}
return mapperMethod;
} }

  从上面源码中,我们可以发现,接口方法的实现其实是通过 MapperMethod 来实现的,且 Mapper接口的每个方法 都会生成一个 MapperMethod 对象,并通过 methodCache 来维护它们之间的关系,而 methodCache 是通过 MapperProxyFactory 传递下来的。

MapperMethod

   MapperMethod 实现接口方法的入口是 execute()方法,我们来看下其内部源码:

  // 实际上都是调用 SqlSession的方法实现
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
// 判断 索要执行的方法类型
if (SqlCommandType.INSERT == command.getType()) {
// 参数转换
Object param = method.convertArgsToSqlCommandParam(args);
// 执行insert
result = rowCountResult(sqlSession.insert(command.getName(), param));
} else if (SqlCommandType.UPDATE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
// 执行 update
result = rowCountResult(sqlSession.update(command.getName(), param));
} else if (SqlCommandType.DELETE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
// 执行 delete
result = rowCountResult(sqlSession.delete(command.getName(), param));
} else if (SqlCommandType.SELECT == command.getType()) {
// 执行 select
if (method.returnsVoid() && method.hasResultHandler()) {
// 没有返回
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
// 返回 List
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
// 返回 Map
result = executeForMap(sqlSession, args);
} else {
// 返回 一个对象
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
} else {
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}

   根据源码我们可以发现其实内部都是 委托 SqlSession 的方法实现的,但它是如何区别什么时候调用哪个 SqlSession 的方法呢?这个就不得不说 MapperMethod 内部维护的 SqlCommand 对象,我们查看 SqlCommand 的构造方法:


public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
// 补全 方法的全名称路径 即 com.xxx.selectByName
String statementName = mapperInterface.getName() + "." + method.getName();
MappedStatement ms = null;
// 从 configuration 中获取到 MappedStatement 对象
if (configuration.hasStatement(statementName)) {
ms = configuration.getMappedStatement(statementName);
} else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // issue #35
String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
if (configuration.hasStatement(parentStatementName)) {
ms = configuration.getMappedStatement(parentStatementName);
}
}
if (ms == null) {
throw new BindingException("Invalid bound statement (not found): " + statementName);
}
// 从 MappedStatement 中获取到方法名 (注意: 节点中的id属性包含命名空间)
name = ms.getId();
// 从 MappedStatement 中获取到 方法的节点标签,即 select|insert|update|delete
type = ms.getSqlCommandType();
if (type == SqlCommandType.UNKNOWN) {
throw new BindingException("Unknown execution method for: " + name);
}
}

   我们通过分析知道 ,SqlCommand 其实是通过从 MappedStatement 中获取到 方法名,以及所要执行的SQl命令类型(select|insert|update|delete)。 这里我们可以明确的发现从configuration 中 获取 MappedStatement 是通过 全称路径的方法去获取的,即 com.xxx.selectByName 这种,调用SqlSession的方法虽然是从 MappedStatement 中获取 id (注意: 节点中的id属性包含命名空间),但实质上都是 com.xxx.selectByName。但我们可以通过这里看出mybatis的Mapper接口方法是不可以重载的。

四、 个人总结

  • 1、 Configuration 维护了一个 MapperRegistry 对象,该对象主要作用就是加载Mapper接口和获取MapperProxy。

  • 2、 MapperRegistry 维护了一个key为 mapper接口class对象,value为 MapperProxyFactory 的map

  • 3、 MapperProxy 是 通过 MapperProxyFactory 创建的。

  • 4、 MapperProxy 实现 Mapper接口方法是委托 MapperMethod 执行的。

  • 5、 MapperMethod 执行接口方法时是通过 SqlCommand 来判断要执行的具体 SQL节点,并且最终委托 SqlSession执行。

  • 6、 SqlCommand 内部的 信息是通过从 MappedStatement 中获取的。

         如果您对这些感兴趣,欢迎star、follow、收藏、转发给予支持!

本文由博客一文多发平台 OpenWrite 发布!