一、概述
我们知道，Mybatis实现增删改查需要进行XML的配置，其基本的配置如下：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="org.mybatis.example.BlogMapper"> <select id="selectBlog" resultType="Blog"> select * from Blog where id = #{id} </select> </mapper>
上面的配置表示我们在命名空间org.mybatis.example.BlogMapper下定义一个ID为selectBlog的查询操作，其操作结果集为Blog，对应的语句为select * from Blog where id = #{id}
那么在实际使用时，我们可以采用如下形式：
SqlSession session = sqlSessionFactory.openSession(); try { Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101); } finally { session.close(); }
这种方式有很明显的缺点就是通过字符串去调用标签定义的SQL，第一容易出错，第二是当XML当中的id修改过以后你不知道在程序当中有多少个地方使用了这个ID,需要手工查找并一一修改。
在Mybatis的新版本中做了一些改进，支持这种方式调用：定义一个接口 方法名，参数需要与XML定义保持一致。
- 1、新建一个com.kang.mapper的包，定义map接口，接口名任意，这里是UserMapper。
package com.kang.mapper; import java.util.List; import com.kang.pojo.User; public interface UserMapper { public User findUserById(int id) throws Exception; public List<User> findUserByUsername(String username) throws Exception; public void insertUser(User user)throws Exception; }
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.kang.mapper.UserMapper"> <select id="findUserById" parameterType="int" resultType="user"> select * from user where id = #{id} </select> <select id="findUserByUsername" parameterType="java.lang.String" resultType="user"> select * from user where username like '%${value}%' </select> <insert id="insertUser" parameterType="user"> <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer"> select LAST_INSERT_ID() </selectKey> insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address}) </insert> </mapper>
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
注意到配置文件中的id属性值和map接口中的方法名是一一对应的。
- 3、在SqlMapConfig.xml中加入映射文件
<mappers> <mapper resource="map/UserMapper.xml" /> </mappers>
//获取session SqlSession session = sqlSessionFactory.openSession() //获取mapper接口的代理对象 UserMapper userMapper = session.getMapper(UserMapper.class) //调用代理对象方法 User user = userMapper.findUserById(27) System.out.println(user) //关闭session session.close() System.out.println("---------执行完毕-----------")
这样以来当我们修改了XML的ID以后，只需要修改接口中的方法就可以了，编译器会在其他使用该接口的地方报错，很容易进行修改。当然好处还不只这些，还可以通过与spring进行无缝集成，动态注入 等等。
关于Mybatis的Mapp接口使用方法请参考这篇博文Mybatis之Mapper动态代理
在上面的例子当中呢，UserMapper是一个接口 它并没有实现类，为什么接口可以直接使用呢? 那是因为MyBbatis使用了JDK动态代理机制动态生成了代理类，那么代理类又是如何多SqlSession进行封装的呢?带着这些疑问，让我们通过分析源代码的方式来解释这些问题。
二、源码解析
Mybatis关于包装Mapper的代码都在org.apache.ibatis.binding 这个包下面。其中有4个类：
MapperRegistry 类是注册Mapper接口与获取代理类实例的工具类。其源码如下：
package org.apache.ibatis.binding;import org.apache.ibatis.builder.annotation.MapperAnnotationBuilder;import org.apache.ibatis.io.ResolverUtil;import org.apache.ibatis.session.Configuration;import org.apache.ibatis.session.SqlSession;import java.util.Collection;import java.util.Collections;import java.util.HashMap;import java.util.Map;import java.util.Set;public class MapperRegistry { private Configuration config; private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>(); public MapperRegistry(Configuration config) { this.config = config; } @SuppressWarnings("unchecked") public <T> T getMapper(Class<T> type, SqlSession sqlSession) { final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type); if (mapperProxyFactory == null) throw new BindingException("Type " + type + " is not known to the MapperRegistry."); try { return mapperProxyFactory.newInstance(sqlSession); } catch (Exception e) { throw new BindingException("Error getting mapper instance. Cause: " + e, e); } } public <T> boolean hasMapper(Class<T> type) { return knownMappers.containsKey(type); } public <T> void addMapper(Class<T> type) { if (type.isInterface()) { if (hasMapper(type)) { throw new BindingException("Type " + type + " is already known to the MapperRegistry."); } boolean loadCompleted = false; try { knownMappers.put(type, new MapperProxyFactory<T>(type)); MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); parser.parse(); loadCompleted = true; } finally { if (!loadCompleted) { knownMappers.remove(type); } } } } public Collection<Class<?>> getMappers() { return Collections.unmodifiableCollection(knownMappers.keySet()); } ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>(); resolverUtil.find(new ResolverUtil.IsA(superType), packageName); Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses(); for (Class<?> mapperClass : mapperSet) { addMapper(mapperClass); } } public void addMappers(String packageName) { addMappers(packageName, Object.class); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
类的getMapper方法里面最后会去调用MapperProxyFactory类的newInstance方法。从上面的源码可以看出来，在调用getMapper方法前会初始化MapperProxyFactory，它是创建Mapper代理对象的工厂，其源码如下：
package org.apache.ibatis.binding;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import org.apache.ibatis.session.SqlSession;public class MapperProxyFactory<T> { private final Class<T> mapperInterface; private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>(); public MapperProxyFactory(Class<T> mapperInterface) { this.mapperInterface = mapperInterface; } public Class<T> getMapperInterface() { return mapperInterface; } public Map<Method, MapperMethod> getMethodCache() { return methodCache; } @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); }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
上述代码中的关键代码是
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
在这里创建了MapperProxy对象 这个类实现了JDK的动态代理接口 InvocationHandler,其源码如下：
package org.apache.ibatis.binding;import java.io.Serializable;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.util.Map;import org.apache.ibatis.session.SqlSession;public class MapperProxy<T> implements InvocationHandler, Serializable { private static final long serialVersionUID = -6424540398559729838L; 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 { if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); } final MapperMethod mapperMethod = cachedMapperMethod(method); return mapperMethod.execute(sqlSession, args); } 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; }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
从源码的意思：从缓存中获得执行方法对应的MapperMethod类实例。如果MapperMethod类实例不存在的情况，创建加入缓存并返回相关的实例。最后调用MapperMethod类的execute方法。
到这里我们可以看到，getMapper方法就是用来获得相关的数据操作类接口。而事实数据操作类邦定了动态代理。所以操据操作类执行方法的时候，会触动每个方法相应的MapperProxy类的invoke方法。所以invoke方法返回的结果就是根据操作类执行方法的结果。这样子我们就知道最后的任务交给了MapperMethod类实例。
那么MapperMethod的详细源码如下：
package org.apache.ibatis.bindingimport org.apache.ibatis.annotations.MapKeyimport org.apache.ibatis.annotations.Paramimport org.apache.ibatis.mapping.MappedStatementimport org.apache.ibatis.mapping.SqlCommandTypeimport org.apache.ibatis.reflection.MetaObjectimport org.apache.ibatis.session.Configurationimport org.apache.ibatis.session.ResultHandlerimport org.apache.ibatis.session.RowBoundsimport org.apache.ibatis.session.SqlSessionimport java.lang.reflect.Arrayimport java.lang.reflect.Methodimport java.util.*//这个类是整个代理机制的核心类，对Sqlsession当中的操作进行了封装public class MapperMethod { //一个内部封 封装了SQL标签的类型 insert update delete select private final SqlCommand command //一个内部类 封装了方法的参数信息 返回类型信息等 private final MethodSignature method //构造参数 public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) { this.command = new SqlCommand(config, mapperInterface, method) this.method = new MethodSignature(config, method) } //这个方法是对SqlSession的包装调用 public Object execute(SqlSession sqlSession, Object[] args) { //定义返回结果 Object result //如果是INSERT操作 if (SqlCommandType.INSERT == command.getType()) { //处理参数 Object param = method.convertArgsToSqlCommandParam(args) //调用sqlSession的insert方法 result = rowCountResult(sqlSession.insert(command.getName(), param)) //如果是UPDATE操作 同上 } else if (SqlCommandType.UPDATE == command.getType()) { Object param = method.convertArgsToSqlCommandParam(args) result = rowCountResult(sqlSession.update(command.getName(), param)) //如果是DELETE操作 同上 } else if (SqlCommandType.DELETE == command.getType()) { Object param = method.convertArgsToSqlCommandParam(args) result = rowCountResult(sqlSession.delete(command.getName(), param)) //如果是SELECT操作 那么情况会多一些 但是也都和sqlSession的查询方法一一对应 } else if (SqlCommandType.SELECT == command.getType()) { //如果返回void 并且参数有resultHandler //则调用 void select(String statement, Object parameter, ResultHandler handler) if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args) result = null //如果返回多行结果这调用 <E> List<E> selectList(String statement, Object parameter) //executeForMany这个方法调用的 } else if (method.returnsMany()) { result = executeForMany(sqlSession, args) //如果返回类型是MAP 则调用executeForMap方法 } else if (method.returnsMap()) { result = executeForMap(sqlSession, args) } else { //否则就是查询单个对象 Object param = method.convertArgsToSqlCommandParam(args) result = sqlSession.selectOne(command.getName(), param) } } else { //如果全都不匹配 说明mapper中定义的方法不对 throw new BindingException("Unknown execution method for: " + command.getName()) } //如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常 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 } private Object rowCountResult(int rowCount) { final Object result if (method.returnsVoid()) { result = null } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) { result = rowCount } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) { result = (long) rowCount } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) { result = (rowCount > 0) } else { throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType()) } return result } private void executeWithResultHandler(SqlSession sqlSession, Object[] args) { MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName()) if (void.class.equals(ms.getResultMaps().get(0).getType())) { throw new BindingException("method " + command.getName() + " needs either a @ResultMap annotation, a @ResultType annotation," + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.") } Object param = method.convertArgsToSqlCommandParam(args) if (method.hasRowBounds()) { RowBounds rowBounds = method.extractRowBounds(args) sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args)) } else { sqlSession.select(command.getName(), param, method.extractResultHandler(args)) } } //返回多行结果 调用sqlSession.selectList方法 private <E> Object executeForMany(SqlSession sqlSession, Object[] args) { List<E> result Object param = method.convertArgsToSqlCommandParam(args) //如果参数含有rowBounds则调用分页的查询 if (method.hasRowBounds()) { RowBounds rowBounds = method.extractRowBounds(args) result = sqlSession.<E>selectList(command.getName(), param, rowBounds) } else { //没有分页则调用普通查询 result = sqlSession.<E>selectList(command.getName(), param) } // issue #510 Collections & arrays support if (!method.getReturnType().isAssignableFrom(result.getClass())) { if (method.getReturnType().isArray()) { return convertToArray(result) } else { return convertToDeclaredCollection(sqlSession.getConfiguration(), result) } } return result } private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) { Object collection = config.getObjectFactory().create(method.getReturnType()) MetaObject metaObject = config.newMetaObject(collection) metaObject.addAll(list) return collection } @SuppressWarnings("unchecked") private <E> E[] convertToArray(List<E> list) { E[] array = (E[]) Array.newInstance(method.getReturnType().getComponentType(), list.size()) array = list.toArray(array) return array } private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) { Map<K, V> result Object param = method.convertArgsToSqlCommandParam(args) if (method.hasRowBounds()) { RowBounds rowBounds = method.extractRowBounds(args) result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds) } else { result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey()) } return result } public static class ParamMap<V> extends HashMap<String, V> { private static final long serialVersionUID = -2212268410512043556L @Override public V get(Object key) { if (!super.containsKey(key)) { throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet()) } return super.get(key) } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
MapperMethod类里面有俩个成员：SqlCommand类和MethodSignature类。从名字上我们大概的能想到一个可能跟SQL语句有关系，一个可能跟要执行的方法有关系。事实也是如此。
上面代码使用一个内部类SqlCommand来封装底层的增删改查操作，确切来讲这一部分的内容跟XxxMapper的XML配置文件里面的select节点、delete节点等有关。我们都会知道节点上有id属性值。那么MyBatis框架会把每一个节点(如：select节点、delete节点）生成一个MappedStatement类。要找到MappedStatement类就必须通过id来获得。有一个细节要注意：代码用到的id = 当前接口类 + XML文件的节点的ID属性。其源码如下：
public static class SqlCommand { private final String name; private final SqlCommandType type; public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException { String statementName = mapperInterface.getName() + "." + method.getName(); MappedStatement ms = null; if (configuration.hasStatement(statementName)) { ms = configuration.getMappedStatement(statementName); } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { 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); } name = ms.getId(); type = ms.getSqlCommandType(); if (type == SqlCommandType.UNKNOWN) { throw new BindingException("Unknown execution method for: " + name); } } public String getName() { return name; } public SqlCommandType getType() { return type; } } public static class MethodSignature { private final boolean returnsMany; private final boolean returnsMap; private final boolean returnsVoid; private final Class<?> returnType; private final String mapKey; private final Integer resultHandlerIndex; private final Integer rowBoundsIndex; private final SortedMap<Integer, String> params; private final boolean hasNamedParameters; public MethodSignature(Configuration configuration, Method method) throws BindingException { this.returnType = method.getReturnType(); this.returnsVoid = void.class.equals(this.returnType); this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray()); this.mapKey = getMapKey(method); this.returnsMap = (this.mapKey != null); this.hasNamedParameters = hasNamedParams(method); this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class); this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class); this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters)); } public Object convertArgsToSqlCommandParam(Object[] args) { final int paramCount = params.size(); if (args == null || paramCount == 0) { return null; } else if (!hasNamedParameters && paramCount == 1) { return args[params.keySet().iterator().next()]; } else { final Map<String, Object> param = new ParamMap<Object>(); int i = 0; for (Map.Entry<Integer, String> entry : params.entrySet()) { param.put(entry.getValue(), args[entry.getKey()]); final String genericParamName = "param" + String.valueOf(i + 1); if (!param.containsKey(genericParamName)) { param.put(genericParamName, args[entry.getKey()]); } i++; } return param; } } public boolean hasRowBounds() { return (rowBoundsIndex != null); } public RowBounds extractRowBounds(Object[] args) { return (hasRowBounds() ? (RowBounds) args[rowBoundsIndex] : null); } public boolean hasResultHandler() { return (resultHandlerIndex != null); } public ResultHandler extractResultHandler(Object[] args) { return (hasResultHandler() ? (ResultHandler) args[resultHandlerIndex] : null); } public String getMapKey() { return mapKey; } public Class<?> getReturnType() { return returnType; } public boolean returnsMany() { return returnsMany; } public boolean returnsMap() { return returnsMap; } public boolean returnsVoid() { return returnsVoid; } private Integer getUniqueParamIndex(Method method, Class<?> paramType) { Integer index = null; final Class<?>[] argTypes = method.getParameterTypes(); for (int i = 0; i < argTypes.length; i++) { if (paramType.isAssignableFrom(argTypes[i])) { if (index == null) { index = i; } else { throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters"); } } } return index; } private String getMapKey(Method method) { String mapKey = null; if (Map.class.isAssignableFrom(method.getReturnType())) { final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class); if (mapKeyAnnotation != null) { mapKey = mapKeyAnnotation.value(); } } return mapKey; } private SortedMap<Integer, String> getParams(Method method, boolean hasNamedParameters) { final SortedMap<Integer, String> params = new TreeMap<Integer, String>(); final Class<?>[] argTypes = method.getParameterTypes(); for (int i = 0; i < argTypes.length; i++) { if (!RowBounds.class.isAssignableFrom(argTypes[i]) && !ResultHandler.class.isAssignableFrom(argTypes[i])) { String paramName = String.valueOf(params.size()); if (hasNamedParameters) { paramName = getParamNameFromAnnotation(method, i, paramName); } params.put(i, paramName); } } return params; } private String getParamNameFromAnnotation(Method method, int i, String paramName) { final Object[] paramAnnos = method.getParameterAnnotations()[i]; for (Object paramAnno : paramAnnos) { if (paramAnno instanceof Param) { paramName = ((Param) paramAnno).value(); } } return paramName; } private boolean hasNamedParams(Method method) { boolean hasNamedParams = false; final Object[][] paramAnnos = method.getParameterAnnotations(); for (Object[] paramAnno : paramAnnos) { for (Object aParamAnno : paramAnno) { if (aParamAnno instanceof Param) { hasNamedParams = true; break; } } } return hasNamedParams; } }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
看到这里的时候，我们就可以回头去找一找在什么时候增加了MappedStatement类。上面之所以可以执行是建立在XML配置信息都被加载进来了。所以MappedStatement类也一定是在加载配置的时候就进行的。请读者们自行查看一下MapperBuilderAssistant类的addMappedStatement方法——加深理解。SqlCommand类的name成员和type成员我们还是关注一下。name成员就是节点的ID，type成员表示查寻还是更新或是删除。至于MethodSignature类呢。他用于说明方法的一些信息，主要有返回信息。
