public interface SqlSession extends Closeable {
 <T> T selectOne(String statement);
 <E> List<E> selectList(String statement, Object parameter);
 int delete(String statement);
 void rollback();
 void commit();
 ...

}

<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;

<select id="selectCountByPath" parameterType="java.lang.String" resultType="java.lang.Long">
 select count(1) FROM config
 WHERE path = #{path}
</select>

public class RowBounds {
 public static final int NO_ROW_OFFSET = 0;
 public static final int NO_ROW_LIMIT = Integer.MAX_VALUE;
 public static final RowBounds DEFAULT = new RowBounds();
 private int offset;
 private int limit;
 public RowBounds() {
 this.offset = NO_ROW_OFFSET;
 this.limit = NO_ROW_LIMIT;
 }
 public RowBounds(int offset, int limit) {
 this.offset = offset;
 this.limit = limit;
 }
}

public class BoundSql {
 private String sql;
 private List<ParameterMapping> parameterMappings;
 private Object parameterObject;
 private Map<String, Object> additionalParameters;
 private MetaObject metaParameters;
 ...

public BoundSql getBoundSql(Object parameterObject) {
 BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 if (parameterMappings == null || parameterMappings.isEmpty()) {
  boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
 }
 // check for nested result maps in parameter mappings (issue #30)
 for (ParameterMapping pm : boundSql.getParameterMappings()) {
  String rmId = pm.getResultMapId();
  if (rmId != null) {
  ResultMap rm = configuration.getResultMap(rmId);
  if (rm != null) {
   hasNestedResultMaps |= rm.hasNestedResultMaps();
  }
  }
 }
 return boundSql;
}

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
 executorType = executorType == null ? defaultExecutorType : executorType;
 executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
 Executor executor;
 if (ExecutorType.BATCH == executorType) {
  executor = new BatchExecutor(this, transaction);
 } else if (ExecutorType.REUSE == executorType) {
  executor = new ReuseExecutor(this, transaction);
 } else {
  executor = new SimpleExecutor(this, transaction);
 }
 if (cacheEnabled) {
  executor = new CachingExecutor(executor);
 }
 //看这里！！！
 executor = (Executor) interceptorChain.pluginAll(executor);
 return executor;
 }

public class Plugin implements InvocationHandler {
 ...
 public static Object wrap(Object target, Interceptor interceptor) {
 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
 Class<?> type = target.getClass();
 Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
 if (interfaces.length > 0) {
  return Proxy.newProxyInstance(
   type.getClassLoader(),
   interfaces,
   new Plugin(target, interceptor, signatureMap));
 }
 return target;
 }
 
 ...
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 try {
  Set<Method> methods = signatureMap.get(method.getDeclaringClass());
  if (methods != null && methods.contains(method)) {
  return interceptor.intercept(new Invocation(target, method, args));
  }
  return method.invoke(target, args);
 } catch (Exception e) {
  throw ExceptionUtil.unwrapThrowable(e);
 }
 }

public interface Transaction {
 Connection getConnection() throws SQLException;
 void commit() throws SQLException;
 void rollback() throws SQLException;
 void close() throws SQLException;
 Integer getTimeout() throws SQLException;
}