Mybatis源码分析获取Mapper

这次分析的入口是

StudentMapper studentMapper=sqlSession.getMapper(StudentMapper.class);

根据上篇分析我们这里获得的sqlSession是DefaultSqlSession,

public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
private Executor executor;
private boolean autoCommit;
private boolean dirty;

public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
this.configuration = configuration;
this.executor = executor;
this.dirty = false;
this.autoCommit = autoCommit;
}
}

1.我们进入getMapper方法

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

这里没有做什么处理，接下来进入configuration.getMapper中

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

利用我们开始解析xml获得的mapperRegistry获取，继续跟进

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap();//这是我们mapperRegistry中保存的
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
MapperProxyFactory mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);//通过上面的HashMap获取mapperProxyFactory
if(mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
} else {
try {
return mapperProxyFactory.newInstance(sqlSession);//生成代理类
} catch (Exception var5) {
throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);
}
}
}

这里就要说一下什么是MapperProxyFactory?

翻译成中文就是映射代理工厂。

private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap();
public MapperProxyFactory(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}

上面构造函数的代码首先会把之前在mapper.xml中配置的那些mapper接口注入进去，这里我们也会有一个方法缓存，我们每个方法都会对应一个MapperMethod其中保存我们已经解析过的sql。接下来我们就会生成我们的代理映射类。

public T newInstance(SqlSession sqlSession) {
MapperProxy mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);
return this.newInstance((MapperProxy)mapperProxy);
}

mapperProxy就是我们的代理类，接下来进入我们的代理类之中。Mybatis实现的是Jdk动态代理，在代理之中最重要的当然是invoke,接下来我们分析。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
} else {
MapperMethod mapperMethod = this.cachedMapperMethod(method);
return mapperMethod.execute(this.sqlSession, args);
}
}

private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = (MapperMethod)this.methodCache.get(method);
if(mapperMethod == null) {
mapperMethod = new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration());
this.methodCache.put(method, mapperMethod);
}

return mapperMethod;
}

1.上面的invoke之中我们首先判断method方法的拥有者类是不是和object.class相等。如果相等就直接执行Invoke。

2.如果不相等通过this.cachedMapperMethod(method);获取我们该方法的缓存映射。

3。调用mapperMethod.execute(this.sqlSession, args); 这是真正的执行过程。

这里MapperMethod非常重要我们这里详细分析：

public class MapperMethod {
private final MapperMethod.SqlCommand command;
private final MapperMethod.MethodSignature method;

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
this.command = new MapperMethod.SqlCommand(config, mapperInterface, method);
this.method = new MapperMethod.MethodSignature(config, method);
}
}

在MapperMethod维护了两个变量SqlCommand 和MethodSignature ，SqlCommand类获取处理的唯一标识及SQL语句类型，MethodSignature类对业务接口方法的入参类型及出参类型进行处理。

在SqlCommand的构造函数中有

public static class SqlCommand {
private final String name;//保存我们唯一标识id
private final SqlCommandType type;//保存我们sql语句类型

public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
String statementName = mapperInterface.getName() + "." + method.getName();
MappedStatement ms = null;
if(configuration.hasStatement(statementName)) {
ms = configuration.getMappedStatement(statementName);
} else if(!mapperInterface.equals(method.getDeclaringClass())) {
String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
if(configuration.hasStatement(parentStatementName)) {
ms = configuration.getMappedStatement(parentStatementName);
}
}

if(ms == null) {
if(method.getAnnotation(Flush.class) == null) {
throw new BindingException("Invalid bound statement (not found): " + statementName);
}

this.name = null;
this.type = SqlCommandType.FLUSH;
} else {
this.name = ms.getId();
this.type = ms.getSqlCommandType();
if(this.type == SqlCommandType.UNKNOWN) {
throw new BindingException("Unknown execution method for: " + this.name);
}
}

}
}

当我们代理实例生成之后，我们利用jdk反射Proxy.newProxyInstance()方法生成我们的代理类。

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

至此我们获取Mapper过程全部分析完毕。简而言之就是生成了利用Proxy动态代理反射生成。