这篇文章我们将从上面两行代码看起，首先就是获得mapper文件对应的映射类，然后执行里面的数据库操作：
public <T> T getMapper(Class<T> type) { return configuration.<T>getMapper(type, this); }在方法里面将映射类的class对象和当前session作为参数在configuration里面查找：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) { return mapperRegistry.getMapper(type, sqlSession); }然后从存放mapper的工厂里面来查找：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) { //根据class对象获取它对应的代理工厂 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 newInstance(SqlSession sqlSession) { //封装成一个代理类 final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache); //作为参数实例化 return newInstance(mapperProxy); }将当前的会话、接口、和方法的缓存封装成一个mapper代理类，然后实例化：
protected T newInstance(MapperProxy<T> mapperProxy) { return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy); }实际上刚刚创建的MapperProxy就是一个拦截器，那么我们所关注的点就是它里面的invoke方法:
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { //当前代理类是否是执行方法的声明类，如果是，直接执行 if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); //如果是默认的方法，则按照执行默认方法的逻辑处理 } else if (isDefaultMethod(method)) { return invokeDefaultMethod(proxy, method, args); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } final MapperMethod mapperMethod = cachedMapperMethod(method); return mapperMethod.execute(sqlSession, args); }首先会判断声明当前方法的是否是一个类，如果不是就需要创建一个MapperMethod ：
public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case INSERT: {... } case UPDATE: {... } case DELETE: {...} case SELECT:... case FLUSH:... default: 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; }在MapperMethod 的execute方法里面会根据method的类型对应数据库的不同的操作进入不同的分支进行执行，在这我们就以select来看：
case SELECT: if (method.returnsVoid() && method.hasResultHandler()) { executeWithResultHandler(sqlSession, args); result = null; } else if (method.returnsMany()) { result = executeForMany(sqlSession, args); } else if (method.returnsMap()) { result = executeForMap(sqlSession, args); } else if (method.returnsCursor()) { result = executeForCursor(sqlSession, args); } else { Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param); } break;根据不同的返回值类型采用不同的执行方法，在后面我们会看到对method的方法调用，所以我们在这就先深入到这个地方，然后我们回到动态代理的创建：
UserMapper mapper = session.getMapper(UserMapper.class);动态代理创建完后就返回了我们需要的接口类型的实例，下面就开始执行具体的方法了：
User user = mapper.selectByPrimaryKey(1);获取主键为1的对象：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); } else if (isDefaultMethod(method)) { return invokeDefaultMethod(proxy, method, args); } } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } final MapperMethod mapperMethod = cachedMapperMethod(method); return mapperMethod.execute(sqlSession, args); }执行代理类的invoke方法，和我们刚才看见的一样，由于在这里mapper文件里面的命名空间对应的类是一个接口，所以在这是会创建一个mappermethod来执行：
Object param = method.convertArgsToSqlCommandParam(args); result = sqlSession.selectOne(command.getName(), param);在execute方法里面由于是select方法且返回值只有一个，所以只会执行上面这段代码段，首先将我们的参数封装成Map或者是单个对象，然后执行数据库操作返回结果：
public <T> T selectOne(String statement, Object parameter) { //执行数据库操作 List<T> list = this.<T>selectList(statement, parameter); if (list.size() == 1) { return list.get(0); } else if (list.size() > 1) { throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size()); } else { return null; } }statement实际上是我们的接口的全限命名和方法的名字，parameter则是我们传入的参数：
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { //根据statement获取对应的sql语句 MappedStatement ms = configuration.getMappedStatement(statement); //执行器执行 return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }首先会根据statement找到对应的sql语句，然后执行器带着sql语句和参数执行query方法：
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { //带着参数从ms中获取绑定的sql BoundSql boundSql = ms.getBoundSql(parameterObject); //生成一个缓存的key CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql); 执行查询 return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }我们之前解析完sql后，存在着一些占位符，所以需要我们传入的参数进行填充，下面我们就来看一下是如何获得绑定的sql的：
public BoundSql getBoundSql(Object parameterObject) { //从当前sqlSource中获得sql BoundSql boundSql = sqlSource.getBoundSql(parameterObject); //获取需要的参数列表 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings(); //如果需要的参数为空，就直接重新创建一个sql if (parameterMappings == null || parameterMappings.isEmpty()) { boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject); } ... return boundSql; }接着看从sqlSource里面获取 sql：
public BoundSql getBoundSql(Object parameterObject) { return new BoundSql(configuration, sql, parameterMappings, parameterObject); }实际上就是创建了要给sql 的对象，保存了我们传入的值。获取到boundSql之后会为当前这次查询生成一个cacheKey：
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) { if (closed) { throw new ExecutorException("Executor was closed."); } CacheKey cacheKey = new CacheKey(); cacheKey.update(ms.getId()); cacheKey.update(rowBounds.getOffset()); cacheKey.update(rowBounds.getLimit()); cacheKey.update(boundSql.getSql()); List<ParameterMapping> parameterMappings = boundSql.getParameterMappings(); TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry(); // mimic DefaultParameterHandler logic for (ParameterMapping parameterMapping : parameterMappings) { if (parameterMapping.getMode() != ParameterMode.OUT) { Object value; String propertyName = parameterMapping.getProperty(); if (boundSql.hasAdditionalParameter(propertyName)) { value = boundSql.getAdditionalParameter(propertyName); } else if (parameterObject == null) { value = null; } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { value = parameterObject; } else { MetaObject metaObject = configuration.newMetaObject(parameterObject); value = metaObject.getValue(propertyName); } cacheKey.update(value); } } if (configuration.getEnvironment() != null) { // issue #176 cacheKey.update(configuration.getEnvironment().getId()); } return cacheKey; }看完我们就会发现，一次完全相同的查询包括相同的statementid，相同的结果集的偏移量和数据量，相同的需要的参数的值，以及相同的sql语句
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { //首先检查缓存中有没有结果 Cache cache = ms.getCache(); //缓存中存在 if (cache != null) { flushCacheIfRequired(ms); if (ms.isUseCache() && resultHandler == null) { ensureNoOutParams(ms, boundSql); @SuppressWarnings("unchecked") List<E> list = (List<E>) tcm.getObject(cache, key); //没有在缓存中获取到值，需要再重新执行查询，然后放到缓存中 if (list == null) { list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); // issue #578 and #116 } return list; } } //缓存中没有，直接从数据库中查询 return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }如果缓存不为空，那么就会先尝试从缓存中获取，获取失败后还会从数据库中查询：
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId()); if (closed) { throw new ExecutorException("Executor was closed."); } //当前没有线程执行查询并且需要刷新缓存，那么就要清空缓存 if (queryStack == 0 && ms.isFlushCacheRequired()) { clearLocalCache(); } List<E> list; try { //每当一个线程要执行缓存就要计一次数 queryStack++; //从缓存中查找，如果没有执行查询 list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { //执行完查询后计数器减1 queryStack--; } if (queryStack == 0) { for (DeferredLoad deferredLoad : deferredLoads) { deferredLoad.load(); } // issue #601 deferredLoads.clear(); if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { // issue #482 clearLocalCache(); } } return list; }这个方法对进行查询的线程的数量进行了统计，并在合适的时刻清除缓存，查询的时候还是会尝试从缓存中查找，找不到的时候再从数据库中查：
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { Configuration configuration = ms.getConfiguration(); //创建一个生成statement的处理器 StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); //生成statement stmt = prepareStatement(handler, ms.getStatementLog()); //执行查询 return handler.<E>query(stmt, resultHandler); } finally { closeStatement(stmt); } }最后通过statement执行的查询，所以说再mybatis的mapper文件中建议使用#就是由于#会被替换成？，在生成最终的sql的时候是作为参数被替换的，而不是简单的字符串拼接，可以防止sql注入：
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; //获取数据库连接 Connection connection = getConnection(statementLog); //准备一些连接信息和超时信息 stmt = handler.prepare(connection, transaction.getTimeout()); //将占位符替换成我们传入的数据 handler.parameterize(stmt); return stmt; }在这方法中就是最终完成了statement的封装并返回。
