工具除了会用，还应该多做点。我觉得使用一个软件工具（开源类），一般会经历几个步骤：

1. 通过wiki了解大致作用，然后开始码代码；

2. 系统性地学习其特性，找出可能需要的点，用上去；

3. 通过阅读其源码，清楚其来龙去脉；

4. 有能力你就去超越别人；

mybatis作为orm框架给我们带来了很多方便，其定制功能也让我们惊喜！还是来看看别人怎么做到的吧！

　　1. 下载git仓库, https://github.com/mybatis/mybatis-3

　　2. 打开IDE, 找到 test 包

　　3. 进入 org.apache.ibatis.autoconstructor.AutoConstructorTest, 有一个完整的sql 样例

  1. public class AutoConstructorTest {
  2.   private static SqlSessionFactory sqlSessionFactory;
  3.  
  4.   @BeforeClass
  5.   public static void setUp() throws Exception {
  6.     // create a SqlSessionFactory
  7.     try (Reader reader = Resources.getResourceAsReader("org/apache/ibatis/autoconstructor/mybatis-config.xml")) {
  8.       sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  9.     }
  10.  
  11.     // populate in-memory database
  12.     BaseDataTest.runScript(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(),
  13.         "org/apache/ibatis/autoconstructor/CreateDB.sql");
  14.   }
  15.  
  16.   @Test
  17.   public void fullyPopulatedSubject() {
  18.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  19.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  20.       final Object subject = mapper.getSubject(1);
  21.       assertNotNull(subject);
  22.     }
  23.   }
  24.  
  25.   @Test(expected = PersistenceException.class)
  26.   public void primitiveSubjects() {
  27.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  28.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  29.       mapper.getSubjects();
  30.     }
  31.   }
  32.  
  33.   @Test
  34.   public void annotatedSubject() {
  35.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  36.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  37.       verifySubjects(mapper.getAnnotatedSubjects());
  38.     }
  39.   }
  40.  
  41.   @Test(expected = PersistenceException.class)
  42.   public void badSubject() {
  43.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  44.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  45.       mapper.getBadSubjects();
  46.     }
  47.   }
  48.  
  49.   @Test
  50.   public void extensiveSubject() {
  51.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  52.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  53.       verifySubjects(mapper.getExtensiveSubject());
  54.     }
  55.   }
  56.  
  57.   private void verifySubjects(final List<?> subjects) {
  58.     assertNotNull(subjects);
  59.     Assertions.assertThat(subjects.size()).isEqualTo(3);
  60.   }
  61. }

目标方法：fullyPopulatedSubject()，最终进行一条 select 查询：

  1. SELECT * FROM subject WHERE id = #{id}

首先执行的肯定 setup()方法了，setup()做了三件事：

1. 加载mybatis-config文件读取到reader中；

2. 将配置文件传递工厂builder中创建会话工厂；

3. 执行hsqldb内存数据库的初始化工作；（非本文重点）

接下来，咱们从源码的角度，主要看会话工厂的创建过程！

创建 sqlSessionFactory

  1.    try (Reader reader = Resources.getResourceAsReader("org/apache/ibatis/autoconstructor/mybatis-config.xml")) {
  2.       sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  3.     }
  4.  
  5. // SqlSessionFactoryBuilder.build(reader) -> XMLConfigBuilder.parse()
  6. // org.apache.ibatis.session.SqlSessionFactoryBuilder
  7.   public SqlSessionFactory build(Reader reader) {
  8.     return build(reader, null, null);
  9.   }
  10.   // 建立factory
  11.   public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
  12.     try {
  13.       XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
  14.       return build(parser.parse());
  15.     } catch (Exception e) {
  16.       throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  17.     } finally {
  18.         // 加载完成后，上下文管理器重置
  19.       ErrorContext.instance().reset();
  20.       try {
  21.         reader.close();
  22.       } catch (IOException e) {
  23.         // Intentionally ignore. Prefer previous error.
  24.       }
  25.     }
  26.   }

标签解析：

  1. /**
  2.  * Offline entity resolver for the MyBatis DTDs
  3.  *
  4.  * @author Clinton Begin
  5.  * @author Eduardo Macarron
  6.  */
  7. public class XMLMapperEntityResolver implements EntityResolver {
  8.  
  9.   private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";
  10.   private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";
  11.   private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";
  12.   private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";
  13.  
  14.   private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
  15.   private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";
  16.  
  17.   /**
  18.    * Converts a public DTD into a local one
  19.    *
  20.    * @param publicId The public id that is what comes after "PUBLIC"
  21.    * @param systemId The system id that is what comes after the public id.
  22.    * @return The InputSource for the DTD
  23.    *
  24.    * @throws org.xml.sax.SAXException If anything goes wrong
  25.    */
  26.   @Override
  27.   public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
  28.     try {
  29.       if (systemId != null) {
  30.         String lowerCaseSystemId = systemId.toLowerCase(Locale.ENGLISH);
  31.         if (lowerCaseSystemId.contains(MYBATIS_CONFIG_SYSTEM) || lowerCaseSystemId.contains(IBATIS_CONFIG_SYSTEM)) {
  32.           return getInputSource(MYBATIS_CONFIG_DTD, publicId, systemId);
  33.         } else if (lowerCaseSystemId.contains(MYBATIS_MAPPER_SYSTEM) || lowerCaseSystemId.contains(IBATIS_MAPPER_SYSTEM)) {
  34.           return getInputSource(MYBATIS_MAPPER_DTD, publicId, systemId);
  35.         }
  36.       }
  37.       return null;
  38.     } catch (Exception e) {
  39.       throw new SAXException(e.toString());
  40.     }
  41.   }
  42.  
  43.   private InputSource getInputSource(String path, String publicId, String systemId) {
  44.     InputSource source = null;
  45.     if (path != null) {
  46.       try {
  47.         InputStream in = Resources.getResourceAsStream(path);
  48.         source = new InputSource(in);
  49.         source.setPublicId(publicId);
  50.         source.setSystemId(systemId);
  51.       } catch (IOException e) {
  52.         // ignore, null is ok
  53.       }
  54.     }
  55.     return source;
  56.   }
  57.  
  58. }

parser

  1. // org.apache.ibatis.parsing.XPathParser.XPathParser(), 设备一些必要参数
  2.  
  3.   public XPathParser(Reader reader, boolean validation, Properties variables, EntityResolver entityResolver) {
  4.     commonConstructor(validation, variables, entityResolver);
  5.     this.document = createDocument(new InputSource(reader));
  6.   }
  7.   private Document createDocument(InputSource inputSource) {
  8.     // important: this must only be called AFTER common constructor
  9.     try {
  10.       DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  11.       factory.setValidating(validation);
  12.  
  13.       factory.setNamespaceAware(false);
  14.       factory.setIgnoringComments(true);
  15.       factory.setIgnoringElementContentWhitespace(false);
  16.       factory.setCoalescing(false);
  17.       factory.setExpandEntityReferences(true);
  18.  
  19.       DocumentBuilder builder = factory.newDocumentBuilder();
  20.       builder.setEntityResolver(entityResolver);
  21.       builder.setErrorHandler(new ErrorHandler() {
  22.         @Override
  23.         public void error(SAXParseException exception) throws SAXException {
  24.           throw exception;
  25.         }
  26.  
  27.         @Override
  28.         public void fatalError(SAXParseException exception) throws SAXException {
  29.           throw exception;
  30.         }
  31.  
  32.         @Override
  33.         public void warning(SAXParseException exception) throws SAXException {
  34.         }
  35.       });
  36.       return builder.parse(inputSource);
  37.     } catch (Exception e) {
  38.       throw new BuilderException("Error creating document instance.  Cause: " + e, e);
  39.     }
  40.   }
  41.

// 在返回fatory的时候调用 return build(parser.parse()); 将 config.xml 的配置全部解析到 configuration 实例中

  1. // 在返回fatory的时候调用 return build(parser.parse());  将 config.xml 的配置全部解析到 configuration 实例中
  2. // org.apache.ibatis.builder.xml.XMLConfigBuilder.parse()
  3.   public Configuration parse() {
  4.     if (parsed) {
  5.       throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  6.     }
  7.     parsed = true;
  8.     // 根元素为 /configuration, 依次向下解析
  9.     parseConfiguration(parser.evalNode("/configuration"));
  10.     return configuration;
  11.   }
  12.  
  13.   // org.apache.ibatis.parsing.XPathParser.evalNode() 映射 xml 属性到 bean
  14.   public XNode evalNode(Object root, String expression) {
  15.     Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
  16.     if (node == null) {
  17.       return null;
  18.     }
  19.     return new XNode(this, node, variables);
  20.   }
  21.  
  22.   private Object evaluate(String expression, Object root, QName returnType) {
  23.     try {
  24.       return xpath.evaluate(expression, root, returnType);
  25.     } catch (Exception e) {
  26.       throw new BuilderException("Error evaluating XPath.  Cause: " + e, e);
  27.     }
  28.   }
  29.

具体解析项如下，从这里也一目了然，配置项支持什么：

  1.   // 解析各配置参数到实例中
  2.   private void parseConfiguration(XNode root) {
  3.     try {
  4.       //issue #117 read properties first
  5.       propertiesElement(root.evalNode("properties"));
  6.       Properties settings = settingsAsProperties(root.evalNode("settings"));
  7.       // 这个配置没有用过吧
  8.       loadCustomVfs(settings);
  9.       // 解析别名设置
  10.       typeAliasesElement(root.evalNode("typeAliases"));
  11.       pluginElement(root.evalNode("plugins"));
  12.       objectFactoryElement(root.evalNode("objectFactory"));
  13.       objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
  14.       reflectorFactoryElement(root.evalNode("reflectorFactory"));
  15.       settingsElement(settings);
  16.       // read it after objectFactory and objectWrapperFactory issue #631
  17.       environmentsElement(root.evalNode("environments"));
  18.       databaseIdProviderElement(root.evalNode("databaseIdProvider"));
  19.       typeHandlerElement(root.evalNode("typeHandlers"));
  20.       // 重要节点，解析 mapper
  21.       mapperElement(root.evalNode("mappers"));
  22.     } catch (Exception e) {
  23.       throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  24.     }
  25.   }

下面依次来看一下都怎么解析各配置项的吧~

properties 解析

  1.   // propertiesElement(root.evalNode("properties"));  url, resource 解析
  2.   private void propertiesElement(XNode context) throws Exception {
  3.     if (context != null) {
  4.       Properties defaults = context.getChildrenAsProperties();
  5.       String resource = context.getStringAttribute("resource");
  6.       String url = context.getStringAttribute("url");
  7.       if (resource != null && url != null) {
  8.         throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
  9.       }
  10.       if (resource != null) {
  11.         defaults.putAll(Resources.getResourceAsProperties(resource));
  12.       } else if (url != null) {
  13.         defaults.putAll(Resources.getUrlAsProperties(url));
  14.       }
  15.       Properties vars = configuration.getVariables();
  16.       if (vars != null) {
  17.         defaults.putAll(vars);
  18.       }
  19.       // 解析完成后，放到 parser 和 configuration 实例中
  20.       parser.setVariables(defaults);
  21.       configuration.setVariables(defaults);
  22.     }
  23.   }

settings 配置项解析，返回内容待处理

  1.   // Properties settings = settingsAsProperties(root.evalNode("settings"));
  2.   private Properties settingsAsProperties(XNode context) {
  3.     if (context == null) {
  4.       return new Properties();
  5.     }
  6.     Properties props = context.getChildrenAsProperties();
  7.     // Check that all settings are known to the configuration class
  8.     MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
  9.     for (Object key : props.keySet()) {
  10.       if (!metaConfig.hasSetter(String.valueOf(key))) {
  11.         throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
  12.       }
  13.     }
  14.     return props;
  15.   }
  16.  
  17.   // loadCustomVfs(settings);  这个...
  18.   private void loadCustomVfs(Properties props) throws ClassNotFoundException {
  19.     String value = props.getProperty("vfsImpl");
  20.     if (value != null) {
  21.       String[] clazzes = value.split(",");
  22.       for (String clazz : clazzes) {
  23.         if (!clazz.isEmpty()) {
  24.           @SuppressWarnings("unchecked")
  25.           Class<? extends VFS> vfsImpl = (Class<? extends VFS>)Resources.classForName(clazz);
  26.           configuration.setVfsImpl(vfsImpl);
  27.         }
  28.       }
  29.     }
  30.   }
  31.

typeAliases 别名设置解析，主要做类型检查，及别名的注册工作

  1.   // typeAliasesElement(root.evalNode("typeAliases"));
  2.   private void typeAliasesElement(XNode parent) {
  3.     if (parent != null) {
  4.       for (XNode child : parent.getChildren()) {
  5.         if ("package".equals(child.getName())) {
  6.           // 针对package配置，需注册一系列别名，以 simpleName 代替
  7.           String typeAliasPackage = child.getStringAttribute("name");
  8.           configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
  9.         } else {
  10.           String alias = child.getStringAttribute("alias");
  11.           String type = child.getStringAttribute("type");
  12.           try {
  13.             Class<?> clazz = Resources.classForName(type);
  14.             if (alias == null) {
  15.               typeAliasRegistry.registerAlias(clazz);
  16.             } else {
  17.               typeAliasRegistry.registerAlias(alias, clazz);
  18.             }
  19.           } catch (ClassNotFoundException e) {
  20.             throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
  21.           }
  22.         }
  23.       }
  24.     }
  25.   }
  26.   // org.apache.ibatis.type.TypeAliasRegistry.registerAlias(), 具体数据结构为 map 封装
  27.   public void registerAlias(Class<?> type) {
  28.     String alias = type.getSimpleName();
  29.     Alias aliasAnnotation = type.getAnnotation(Alias.class);
  30.     if (aliasAnnotation != null) {
  31.       alias = aliasAnnotation.value();
  32.     }
  33.     registerAlias(alias, type);
  34.   }
  35.   public void registerAlias(String alias, Class<?> value) {
  36.     if (alias == null) {
  37.       throw new TypeException("The parameter alias cannot be null");
  38.     }
  39.     // issue #748
  40.     String key = alias.toLowerCase(Locale.ENGLISH);
  41.     if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
  42.       throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
  43.     }
  44.     TYPE_ALIASES.put(key, value);
  45.   }

plugins 配置项解析，将属性注入的plugin, 添加 plugin 到 configuration

  1.   // pluginElement(root.evalNode("plugins"));
  2.   private void pluginElement(XNode parent) throws Exception {
  3.     if (parent != null) {
  4.       for (XNode child : parent.getChildren()) {
  5.         String interceptor = child.getStringAttribute("interceptor");
  6.         Properties properties = child.getChildrenAsProperties();
  7.         // 先创建一个plugin实例，备用
  8.         Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
  9.         // 配置属性的注入，回调
  10.         interceptorInstance.setProperties(properties);
  11.         // 添加到 configuration
  12.         configuration.addInterceptor(interceptorInstance);
  13.       }
  14.     }
  15.   }
  16. public class InterceptorChain {
  17.  
  18.   private final List<Interceptor> interceptors = new ArrayList<>();
  19.  
  20.   public Object pluginAll(Object target) {
  21.     for (Interceptor interceptor : interceptors) {
  22.       target = interceptor.plugin(target);
  23.     }
  24.     return target;
  25.   }
  26.  
  27.   public void addInterceptor(Interceptor interceptor) {
  28.     interceptors.add(interceptor);
  29.   }
  30.  
  31.   public List<Interceptor> getInterceptors() {
  32.     return Collections.unmodifiableList(interceptors);
  33.   }
  34.  
  35. }

objectFactory 配置项解析，与plugin原理相似，做替换自定义作用

  1.   // objectFactoryElement(root.evalNode("objectFactory"));
  2.   private void objectFactoryElement(XNode context) throws Exception {
  3.     if (context != null) {
  4.       String type = context.getStringAttribute("type");
  5.       Properties properties = context.getChildrenAsProperties();
  6.       ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
  7.       factory.setProperties(properties);
  8.       configuration.setObjectFactory(factory);
  9.     }
  10.   }
  11.  
  12.   // objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); 没什么特别
  13.   private void objectWrapperFactoryElement(XNode context) throws Exception {
  14.     if (context != null) {
  15.       String type = context.getStringAttribute("type");
  16.       ObjectWrapperFactory factory = (ObjectWrapperFactory) resolveClass(type).newInstance();
  17.       configuration.setObjectWrapperFactory(factory);
  18.     }
  19.   }
  1.   // reflectorFactoryElement(root.evalNode("reflectorFactory"));
  2.   private void reflectorFactoryElement(XNode context) throws Exception {
  3.     if (context != null) {
  4.        String type = context.getStringAttribute("type");
  5.        ReflectorFactory factory = (ReflectorFactory) resolveClass(type).newInstance();
  6.        configuration.setReflectorFactory(factory);
  7.     }
  8.   }

settings 选项解析，设置各种开关, 如缓存

  1.   // settingsElement(settings);  设置各种开关, 如缓存
  2.   private void settingsElement(Properties props) throws Exception {
  3.     configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
  4.     configuration.setAutoMappingUnknownColumnBehavior(AutoMappingUnknownColumnBehavior.valueOf(props.getProperty("autoMappingUnknownColumnBehavior", "NONE")));
  5.     configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
  6.     configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
  7.     configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
  8.     configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), false));
  9.     configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
  10.     configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
  11.     configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
  12.     configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
  13.     configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
  14.     configuration.setDefaultFetchSize(integerValueOf(props.getProperty("defaultFetchSize"), null));
  15.     configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
  16.     configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
  17.     configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
  18.     configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
  19.     configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
  20.     configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
  21.     configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
  22.     @SuppressWarnings("unchecked")
  23.     Class<? extends TypeHandler> typeHandler = (Class<? extends TypeHandler>)resolveClass(props.getProperty("defaultEnumTypeHandler"));
  24.     configuration.setDefaultEnumTypeHandler(typeHandler);
  25.     configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
  26.     configuration.setUseActualParamName(booleanValueOf(props.getProperty("useActualParamName"), true));
  27.     configuration.setReturnInstanceForEmptyRow(booleanValueOf(props.getProperty("returnInstanceForEmptyRow"), false));
  28.     configuration.setLogPrefix(props.getProperty("logPrefix"));
  29.     @SuppressWarnings("unchecked")
  30.     Class<? extends Log> logImpl = (Class<? extends Log>)resolveClass(props.getProperty("logImpl"));
  31.     configuration.setLogImpl(logImpl);
  32.     configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
  33.   }
  34.

environments 环境配置设置，根据指定环境，获取相应配置，加载数据源配置

  1.   // environmentsElement(root.evalNode("environments")); 环境配置
  2.   private void environmentsElement(XNode context) throws Exception {
  3.     if (context != null) {
  4.       if (environment == null) {
  5.         // 默认为 development
  6.         environment = context.getStringAttribute("default");
  7.       }
  8.       for (XNode child : context.getChildren()) {
  9.         String id = child.getStringAttribute("id");
  10.         // 查找当前环境配置，指定加载
  11.         if (isSpecifiedEnvironment(id)) {
  12.           // 事务管理、数据源
  13.           TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
  14.           DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
  15.           DataSource dataSource = dsFactory.getDataSource();
  16.           Environment.Builder environmentBuilder = new Environment.Builder(id)
  17.               .transactionFactory(txFactory)
  18.               .dataSource(dataSource);
  19.           configuration.setEnvironment(environmentBuilder.build());
  20.         }
  21.       }
  22.     }
  23.   }
  24.     // 环境配置包含， id, 事务管理, 数据源
  25.     public Environment build() {
  26.       return new Environment(this.id, this.transactionFactory, this.dataSource);
  27.     }

databaseIdProvider 解析，对多数据源，包含多 机器，或多类型数据库 mysql,sqlserver

  1.   // databaseIdProviderElement(root.evalNode("databaseIdProvider"));
  2.   private void databaseIdProviderElement(XNode context) throws Exception {
  3.     DatabaseIdProvider databaseIdProvider = null;
  4.     if (context != null) {
  5.       String type = context.getStringAttribute("type");
  6.       // awful patch to keep backward compatibility
  7.       if ("VENDOR".equals(type)) {
  8.           type = "DB_VENDOR";
  9.       }
  10.       Properties properties = context.getChildrenAsProperties();
  11.       databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
  12.       databaseIdProvider.setProperties(properties);
  13.     }
  14.     Environment environment = configuration.getEnvironment();
  15.     if (environment != null && databaseIdProvider != null) {
  16.       String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
  17.       configuration.setDatabaseId(databaseId);
  18.     }
  19.   }

自定义 typeHandler

  1.   // typeHandlerElement(root.evalNode("typeHandlers")); 自定义 typeHandler
  2.   private void typeHandlerElement(XNode parent) throws Exception {
  3.     if (parent != null) {
  4.       for (XNode child : parent.getChildren()) {
  5.         if ("package".equals(child.getName())) {
  6.           String typeHandlerPackage = child.getStringAttribute("name");
  7.           typeHandlerRegistry.register(typeHandlerPackage);
  8.         } else {
  9.           String javaTypeName = child.getStringAttribute("javaType");
  10.           String jdbcTypeName = child.getStringAttribute("jdbcType");
  11.           String handlerTypeName = child.getStringAttribute("handler");
  12.           Class<?> javaTypeClass = resolveClass(javaTypeName);
  13.           JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
  14.           Class<?> typeHandlerClass = resolveClass(handlerTypeName);
  15.           if (javaTypeClass != null) {
  16.             if (jdbcType == null) {
  17.               typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
  18.             } else {
  19.               typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
  20.             }
  21.           } else {
  22.             typeHandlerRegistry.register(typeHandlerClass);
  23.           }
  24.         }
  25.       }
  26.     }
  27.   }
  28.   // org.apache.ibatis.type.TypeHandlerRegistry.register(), 以map保存映射
  29.   private void register(Type javaType, JdbcType jdbcType, TypeHandler<?> handler) {
  30.     if (javaType != null) {
  31.       Map<JdbcType, TypeHandler<?>> map = TYPE_HANDLER_MAP.get(javaType);
  32.       if (map == null || map == NULL_TYPE_HANDLER_MAP) {
  33.         map = new HashMap<>();
  34.         TYPE_HANDLER_MAP.put(javaType, map);
  35.       }
  36.       map.put(jdbcType, handler);
  37.     }
  38.     ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
  39.   }

mapper 解析，crud

  1.   // mapperElement(root.evalNode("mappers"));
  2.   private void mapperElement(XNode parent) throws Exception {
  3.     if (parent != null) {
  4.       for (XNode child : parent.getChildren()) {
  5.         if ("package".equals(child.getName())) {
  6.           String mapperPackage = child.getStringAttribute("name");
  7.           configuration.addMappers(mapperPackage);
  8.         } else {
  9.           String resource = child.getStringAttribute("resource");
  10.           String url = child.getStringAttribute("url");
  11.           String mapperClass = child.getStringAttribute("class");
  12.           if (resource != null && url == null && mapperClass == null) {
  13.             ErrorContext.instance().resource(resource);
  14.             InputStream inputStream = Resources.getResourceAsStream(resource);
  15.             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
  16.             mapperParser.parse();
  17.           } else if (resource == null && url != null && mapperClass == null) {
  18.             ErrorContext.instance().resource(url);
  19.             InputStream inputStream = Resources.getUrlAsStream(url);
  20.             XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
  21.             mapperParser.parse();
  22.           } else if (resource == null && url == null && mapperClass != null) {
  23.             Class<?> mapperInterface = Resources.classForName(mapperClass);
  24.             configuration.addMapper(mapperInterface);
  25.           } else {
  26.             throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
  27.           }
  28.         }
  29.       }
  30.     }
  31.   }

mapper解析细节

  1.   // org.apache.ibatis.builder.xml.XMLMapperBuilder.parse() mapper解析细节
  2.   public void parse() {
  3.     // 只解析一次 namespace
  4.     if (!configuration.isResourceLoaded(resource)) {
  5.       configurationElement(parser.evalNode("/mapper"));
  6.       configuration.addLoadedResource(resource);
  7.       bindMapperForNamespace();
  8.     }
  9.  
  10.     // 解析 resultMaps
  11.     parsePendingResultMaps();
  12.     parsePendingCacheRefs();
  13.     parsePendingStatements();
  14.   }
  15.   private void configurationElement(XNode context) {
  16.     try {
  17.       String namespace = context.getStringAttribute("namespace");
  18.       if (namespace == null || namespace.equals("")) {
  19.         throw new BuilderException("Mapper's namespace cannot be empty");
  20.       }
  21.       builderAssistant.setCurrentNamespace(namespace);
  22.       cacheRefElement(context.evalNode("cache-ref"));
  23.       cacheElement(context.evalNode("cache"));
  24.       parameterMapElement(context.evalNodes("/mapper/parameterMap"));
  25.       resultMapElements(context.evalNodes("/mapper/resultMap"));
  26.       sqlElement(context.evalNodes("/mapper/sql"));
  27.       buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
  28.     } catch (Exception e) {
  29.       throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
  30.     }
  31.   }
  32.  
  33.   private void parsePendingResultMaps() {
  34.     Collection<ResultMapResolver> incompleteResultMaps = configuration.getIncompleteResultMaps();
  35.     synchronized (incompleteResultMaps) {
  36.       Iterator<ResultMapResolver> iter = incompleteResultMaps.iterator();
  37.       while (iter.hasNext()) {
  38.         try {
  39.           iter.next().resolve();
  40.           iter.remove();
  41.         } catch (IncompleteElementException e) {
  42.           // ResultMap is still missing a resource...
  43.         }
  44.       }
  45.     }
  46.   }
  47.  
  48.   private void parsePendingCacheRefs() {
  49.     Collection<CacheRefResolver> incompleteCacheRefs = configuration.getIncompleteCacheRefs();
  50.     synchronized (incompleteCacheRefs) {
  51.       Iterator<CacheRefResolver> iter = incompleteCacheRefs.iterator();
  52.       while (iter.hasNext()) {
  53.         try {
  54.           iter.next().resolveCacheRef();
  55.           iter.remove();
  56.         } catch (IncompleteElementException e) {
  57.           // Cache ref is still missing a resource...
  58.         }
  59.       }
  60.     }
  61.   }
  62.  
  63.   private void parsePendingStatements() {
  64.     Collection<XMLStatementBuilder> incompleteStatements = configuration.getIncompleteStatements();
  65.     synchronized (incompleteStatements) {
  66.       Iterator<XMLStatementBuilder> iter = incompleteStatements.iterator();
  67.       while (iter.hasNext()) {
  68.         try {
  69.           iter.next().parseStatementNode();
  70.           iter.remove();
  71.         } catch (IncompleteElementException e) {
  72.           // Statement is still missing a resource...
  73.         }
  74.       }
  75.     }
  76.   }

// 最后，返回一个 DefaultSqlSessionFactory, 载入配置项

  1.   public SqlSessionFactory build(Configuration config) {
  2.     return new DefaultSqlSessionFactory(config);
  3.   }

// 会话创建好后，可以执行sql了

  1.   public void fullyPopulatedSubject() {
  2.     // 打开一个连接，使用完成后关闭
  3.     try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
  4.       final AutoConstructorMapper mapper = sqlSession.getMapper(AutoConstructorMapper.class);
  5.       final Object subject = mapper.getSubject(1);
  6.       assertNotNull(subject);
  7.     }
  8.   }

2. 打开获得一个数据库会话连接

  1. // org.apache.ibatis.session.defaults.SqlSession.openSession(); 打开一个数据库连接
  2.  
  3.   @Override
  4.   public SqlSession openSession() {
  5.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  6.   }
  7.   private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  8.     Transaction tx = null;
  9.     try {
  10.         // 运行环境获取
  11.       final Environment environment = configuration.getEnvironment();
  12.       // 事务管理工厂获取
  13.       final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
  14.       // 创建新事务
  15.       tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
  16.       // new Executor
  17.       final Executor executor = configuration.newExecutor(tx, execType);
  18.       // 最后返回 DefaultSqlSession 使用
  19.       return new DefaultSqlSession(configuration, executor, autoCommit);
  20.     } catch (Exception e) {
  21.       closeTransaction(tx); // may have fetched a connection so lets call close()
  22.       throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  23.     } finally {
  24.       // 关闭上下文监控
  25.       ErrorContext.instance().reset();
  26.     }
  27.   }
  1.   // org.apache.ibatis.session.Configuration.newExecutor()
  2.   public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  3.     executorType = executorType == null ? defaultExecutorType : executorType;
  4.     executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  5.     Executor executor;
  6.     // 根据不同请求类型创建不同的 executor
  7.     if (ExecutorType.BATCH == executorType) {
  8.       executor = new BatchExecutor(this, transaction);
  9.     } else if (ExecutorType.REUSE == executorType) {
  10.       executor = new ReuseExecutor(this, transaction);
  11.     } else {
  12.       // 默认为 SIMPLE
  13.       executor = new SimpleExecutor(this, transaction);
  14.     }
  15.     if (cacheEnabled) {
  16.       // 创建缓存管理，将缓存请求委托给 executor 处理
  17.       executor = new CachingExecutor(executor);
  18.     }
  19.     // 处理plugin 请求
  20.     executor = (Executor) interceptorChain.pluginAll(executor);
  21.     return executor;
  22.   }
  23.   // org.apache.ibatis.executor.CachingExecutor
  24.   public CachingExecutor(Executor delegate) {
  25.     this.delegate = delegate;
  26.     delegate.setExecutorWrapper(this);
  27.   }
  28.  
  29.   // 最后将加载好的各种配置和实际处理，由 DefaultSqlSession 包装好后返回
  30.   public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
  31.     this.configuration = configuration;
  32.     this.executor = executor;
  33.     this.dirty = false;
  34.     this.autoCommit = autoCommit;
  35.   }

3. 获取mapper,准备调用查询

  1.   // org.apache.ibatis.session.defaults.DefaultSqlSession.getMapper()
  2.   @Override
  3.   public <T> T getMapper(Class<T> type) {
  4.     return configuration.<T>getMapper(type, this);
  5.   }
  6.  
  7.   // org.apache.ibatis.binding.MapperRegistry.getMapper()
  8.   @SuppressWarnings("unchecked")
  9.   public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  10.     // 获取 MapperProxyFactory
  11.     final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  12.     if (mapperProxyFactory == null) {
  13.       throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  14.     }
  15.     try {
  16.       // 创建 mapper 实例
  17.       return mapperProxyFactory.newInstance(sqlSession);
  18.     } catch (Exception e) {
  19.       throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  20.     }
  21.   }
  22.  
  23.   // org.apache.ibatis.binding.newInstance();
  24.   public T newInstance(SqlSession sqlSession) {
  25.     final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
  26.     return newInstance(mapperProxy);
  27.   }

4. select, 查询数据

  1.   //mapper.getSubject(1); 查询数据
  2.   @Override
  3.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  4.     try {
  5.       if (Object.class.equals(method.getDeclaringClass())) {
  6.         return method.invoke(this, args);
  7.       } else if (isDefaultMethod(method)) {
  8.         return invokeDefaultMethod(proxy, method, args);
  9.       }
  10.     } catch (Throwable t) {
  11.       throw ExceptionUtil.unwrapThrowable(t);
  12.     }
  13.     // 加载缓存包装方法
  14.     final MapperMethod mapperMethod = cachedMapperMethod(method);
  15.     // 执行查询
  16.     return mapperMethod.execute(sqlSession, args);
  17.   }
  18.  
  19.   private MapperMethod cachedMapperMethod(Method method) {
  20.     return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  21.   }
  22.  
  23.   // org.apache.ibatis.binding.MapperMethod.execute(sqlSession, args); 针对不同类型语句，做不同调用
  24.   public Object execute(SqlSession sqlSession, Object[] args) {
  25.     Object result;
  26.     switch (command.getType()) {
  27.       case INSERT: {
  28.         Object param = method.convertArgsToSqlCommandParam(args);
  29.         result = rowCountResult(sqlSession.insert(command.getName(), param));
  30.         break;
  31.       }
  32.       case UPDATE: {
  33.         Object param = method.convertArgsToSqlCommandParam(args);
  34.         result = rowCountResult(sqlSession.update(command.getName(), param));
  35.         break;
  36.       }
  37.       case DELETE: {
  38.         Object param = method.convertArgsToSqlCommandParam(args);
  39.         result = rowCountResult(sqlSession.delete(command.getName(), param));
  40.         break;
  41.       }
  42.       case SELECT:
  43.         if (method.returnsVoid() && method.hasResultHandler()) {
  44.           executeWithResultHandler(sqlSession, args);
  45.           result = null;
  46.         } else if (method.returnsMany()) {
  47.           result = executeForMany(sqlSession, args);
  48.         } else if (method.returnsMap()) {
  49.           result = executeForMap(sqlSession, args);
  50.         } else if (method.returnsCursor()) {
  51.           result = executeForCursor(sqlSession, args);
  52.         } else {
  53.           // 转换参数
  54.           Object param = method.convertArgsToSqlCommandParam(args);
  55.           // 执行单条查询
  56.           result = sqlSession.selectOne(command.getName(), param);
  57.           if (method.returnsOptional() &&
  58.               (result == null || !method.getReturnType().equals(result.getClass()))) {
  59.             result = Optional.ofNullable(result);
  60.           }
  61.         }
  62.         break;
  63.       case FLUSH:
  64.         result = sqlSession.flushStatements();
  65.         break;
  66.       default:
  67.         throw new BindingException("Unknown execution method for: " + command.getName());
  68.     }
  69.     if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
  70.       throw new BindingException("Mapper method '" + command.getName()
  71.           + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  72.     }
  73.     return result;
  74.   }
  1.   // org.apache.ibatis.reflection.ParamNameResolver.getNamedParams() 返回参数，如果是单个参数，直接返回参数值
  2.   //  如果是多个参数，则以 map 形式返回
  3.   public Object getNamedParams(Object[] args) {
  4.     final int paramCount = names.size();
  5.     if (args == null || paramCount == 0) {
  6.       return null;
  7.     } else if (!hasParamAnnotation && paramCount == 1) {
  8.       return args[names.firstKey()];
  9.     } else {
  10.       final Map<String, Object> param = new ParamMap<>();
  11.       int i = 0;
  12.       for (Map.Entry<Integer, String> entry : names.entrySet()) {
  13.         param.put(entry.getValue(), args[entry.getKey()]);
  14.         // add generic param names (param1, param2, ...)
  15.         final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
  16.         // ensure not to overwrite parameter named with @Param
  17.         if (!names.containsValue(genericParamName)) {
  18.           param.put(genericParamName, args[entry.getKey()]);
  19.         }
  20.         i++;
  21.       }
  22.       return param;
  23.     }
  24.   }

selectOne

  1.   // org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(command.getName(), param);
  2.   @Override
  3.   public <T> T selectOne(String statement, Object parameter) {
  4.     // Popular vote was to return null on 0 results and throw exception on too many.
  5.     // 查询单条记录时，默认也是先查询list,然后取第一条
  6.     List<T> list = this.<T>selectList(statement, parameter);
  7.     if (list.size() == 1) {
  8.       return list.get(0);
  9.     } else if (list.size() > 1) {
  10.       throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
  11.     } else {
  12.       return null;
  13.     }
  14.   }
  15.  
  16.   // 查询列表
  17.   @Override
  18.   public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  19.     try {
  20.       // 先获取执行语句，此处 statement 为 id
  21.       MappedStatement ms = configuration.getMappedStatement(statement);
  22.       return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
  23.     } catch (Exception e) {
  24.       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  25.     } finally {
  26.       ErrorContext.instance().reset();
  27.     }
  28.   }
  29.  
  30.   // org.apache.ibatis.session.Configuration.getMappedStatement(id), 获取初始化解析出来的语句
  31.   public MappedStatement getMappedStatement(String id) {
  32.     return this.getMappedStatement(id, true);
  33.   }
  34.   public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
  35.     if (validateIncompleteStatements) {
  36.       buildAllStatements();
  37.     }
  38.     return mappedStatements.get(id);
  39.   }

包装执行 query

  1.   // executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
  2.   // org.apache.ibatis.executor.CachingExecutor.query()
  3.   @Override
  4.   public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  5.     // 获取sql
  6.     BoundSql boundSql = ms.getBoundSql(parameterObject);
  7.     CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  8.     return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  9.   }
  10.  
  11.   // org.apache.ibatis.mapping.MappedStatement.getBoundSql()
  12.   public BoundSql getBoundSql(Object parameterObject) {
  13.     BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
  14.     // 字段映射
  15.     List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  16.     if (parameterMappings == null || parameterMappings.isEmpty()) {
  17.       boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
  18.     }
  19.  
  20.     // check for nested result maps in parameter mappings (issue #30)
  21.     for (ParameterMapping pm : boundSql.getParameterMappings()) {
  22.       String rmId = pm.getResultMapId();
  23.       if (rmId != null) {
  24.         ResultMap rm = configuration.getResultMap(rmId);
  25.         if (rm != null) {
  26.           hasNestedResultMaps |= rm.hasNestedResultMaps();
  27.         }
  28.       }
  29.     }
  30.  
  31.     return boundSql;
  32.   }
  33.  
  34.   // CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  35.   // return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  36.   // org.apache.ibatis.executor.CachingExecutor.query()
  37.   @Override
  38.   public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  39.       throws SQLException {
  40.     Cache cache = ms.getCache();
  41.     if (cache != null) {
  42.       flushCacheIfRequired(ms);
  43.       if (ms.isUseCache() && resultHandler == null) {
  44.         ensureNoOutParams(ms, boundSql);
  45.         @SuppressWarnings("unchecked")
  46.         List<E> list = (List<E>) tcm.getObject(cache, key);
  47.         if (list == null) {
  48.           list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  49.           tcm.putObject(cache, key, list); // issue #578 and #116
  50.         }
  51.         return list;
  52.       }
  53.     }
  54.     return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  55.   }

前面的query是一个cache的包装类，其实际查询动作需要委托给excuttor，而我们主要关心 queryFromDb 逻辑！

  1.   // org.apache.ibatis.executor.SimpleExecutor.query() / BaseExecutor
  2.   @SuppressWarnings("unchecked")
  3.   @Override
  4.   public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  5.     ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  6.     if (closed) {
  7.       throw new ExecutorException("Executor was closed.");
  8.     }
  9.     // 缓存刷新
  10.     if (queryStack == 0 && ms.isFlushCacheRequired()) {
  11.       clearLocalCache();
  12.     }
  13.     List<E> list;
  14.     try {
  15.       queryStack++;
  16.       list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  17.       if (list != null) {
  18.         handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  19.       } else {
  20.         // 没有缓存，走db
  21.         list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  22.       }
  23.     } finally {
  24.       queryStack--;
  25.     }
  26.     if (queryStack == 0) {
  27.       for (DeferredLoad deferredLoad : deferredLoads) {
  28.         deferredLoad.load();
  29.       }
  30.       // issue #601
  31.       deferredLoads.clear();
  32.       if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
  33.         // issue #482
  34.         clearLocalCache();
  35.       }
  36.     }
  37.     return list;
  38.   }
  39.  
  40.   // BaseExecutor
  41.   private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  42.     List<E> list;
  43.     // 缓存占位符
  44.     localCache.putObject(key, EXECUTION_PLACEHOLDER);
  45.     try {
  46.       list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  47.     } finally {
  48.       // 防止异常情况，保证将占位缓存删除
  49.       localCache.removeObject(key);
  50.     }
  51.     // 操作完成后，重新放入缓存
  52.     localCache.putObject(key, list);
  53.     if (ms.getStatementType() == StatementType.CALLABLE) {
  54.       localOutputParameterCache.putObject(key, parameter);
  55.     }
  56.     return list;
  57.   }
  58.

执行 doQuery，主要是获取完整的 statement，使handler有据可查！

  1.   @Override
  2.   public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  3.     Statement stmt = null;
  4.     try {
  5.       // 获取全局配置
  6.       Configuration configuration = ms.getConfiguration();
  7.       // 获取statement, 处理 JDBC 接口
  8.       StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  9.       stmt = prepareStatement(handler, ms.getStatementLog());
  10.       return handler.<E>query(stmt, resultHandler);
  11.     } finally {
  12.       closeStatement(stmt);
  13.     }
  14.   }
  15.     // org.apache.ibatis.session.Configuration.newStatementHandler(), 兼顾 plugins,
  16.   public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  17.     StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  18.     statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  19.     return statementHandler;
  20.   }

db查询

  1.   // 为不同处理类型，建立不同的 handler
  2.   public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  3.  
  4.     switch (ms.getStatementType()) {
  5.       case STATEMENT:
  6.         delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  7.         break;
  8.       case PREPARED:
  9.         delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  10.         break;
  11.       case CALLABLE:
  12.         delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  13.         break;
  14.       default:
  15.         throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
  16.     }
  17.  
  18.   }
  19.  
  20.   //stmt = prepareStatement(handler, ms.getStatementLog());
  21.   // org.apache.ibatis.executor.SimpleExecutor.prepareStatement(), 获取 statement, JDBC
  22.   private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  23.     Statement stmt;
  24.     Connection connection = getConnection(statementLog);
  25.     // sql录入
  26.     stmt = handler.prepare(connection, transaction.getTimeout());
  27.     // 参数绑定
  28.     handler.parameterize(stmt);
  29.     return stmt;
  30.   }
  31.  
  32.   // BaseExecutor
  33.   protected Connection getConnection(Log statementLog) throws SQLException {
  34.     Connection connection = transaction.getConnection();
  35.     if (statementLog.isDebugEnabled()) {
  36.       return ConnectionLogger.newInstance(connection, statementLog, queryStack);
  37.     } else {
  38.       return connection;
  39.     }
  40.   }
  41.  
  42.   // org.apache.ibatis.transaction.jdbc.JdbcTransaction.getConnection()
  43.   @Override
  44.   public Connection getConnection() throws SQLException {
  45.     if (connection == null) {
  46.       // 为空时新建 connection
  47.       openConnection();
  48.     }
  49.     return connection;
  50.   }
  51.  
  52.   protected void openConnection() throws SQLException {
  53.     if (log.isDebugEnabled()) {
  54.       log.debug("Opening JDBC Connection");
  55.     }
  56.     connection = dataSource.getConnection();
  57.     if (level != null) {
  58.       connection.setTransactionIsolation(level.getLevel());
  59.     }
  60.     setDesiredAutoCommit(autoCommit);
  61.   }
  62.  
  63.   // org.apache.ibatis.datasource.unpooled.getConnection()
  64.   @Override
  65.   public Connection getConnection() throws SQLException {
  66.     return doGetConnection(username, password);
  67.   }
  68.  
  69.   private Connection doGetConnection(String username, String password) throws SQLException {
  70.     Properties props = new Properties();
  71.     if (driverProperties != null) {
  72.       props.putAll(driverProperties);
  73.     }
  74.     if (username != null) {
  75.       props.setProperty("user", username);
  76.     }
  77.     if (password != null) {
  78.       props.setProperty("password", password);
  79.     }
  80.     return doGetConnection(props);
  81.   }
  82.  
  83.   private Connection doGetConnection(Properties properties) throws SQLException {
  84.     // 如果没有初始化驱动，初始化
  85.     initializeDriver();
  86.     //
  87.     Connection connection = DriverManager.getConnection(url, properties);
  88.     configureConnection(connection);
  89.     return connection;
  90.   }
  91.  
  92.   private synchronized void initializeDriver() throws SQLException {
  93.     if (!registeredDrivers.containsKey(driver)) {
  94.       Class<?> driverType;
  95.       try {
  96.         // 加载驱动
  97.         if (driverClassLoader != null) {
  98.           driverType = Class.forName(driver, true, driverClassLoader);
  99.         } else {
  100.           driverType = Resources.classForName(driver);
  101.         }
  102.         // DriverManager requires the driver to be loaded via the system ClassLoader.
  103.         // http://www.kfu.com/~nsayer/Java/dyn-jdbc.html
  104.         Driver driverInstance = (Driver)driverType.newInstance();
  105.         DriverManager.registerDriver(new DriverProxy(driverInstance));
  106.         registeredDrivers.put(driver, driverInstance);
  107.       } catch (Exception e) {
  108.         throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e);
  109.       }
  110.     }
  111.   }
  112.  
  113.   private void configureConnection(Connection conn) throws SQLException {
  114.     if (autoCommit != null && autoCommit != conn.getAutoCommit()) {
  115.       conn.setAutoCommit(autoCommit);
  116.     }
  117.     if (defaultTransactionIsolationLevel != null) {
  118.       conn.setTransactionIsolation(defaultTransactionIsolationLevel);
  119.     }
  120.   }
  121.  
  122. // stmt = handler.prepare(connection, transaction.getTimeout()); 组装sql
  123. // org.apache.ibatis.executor.statement.RoutingStatementHandler.prepare()
  124.   @Override
  125.   public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  126.     return delegate.prepare(connection, transactionTimeout);
  127.   }
  128.  
  129.   // org.apache.ibatis.executor.statement.PreparedStatementHandler.
  130.   @Override
  131.   public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  132.     ErrorContext.instance().sql(boundSql.getSql());
  133.     Statement statement = null;
  134.     try {
  135.       // select * from tab where id = ?
  136.       statement = instantiateStatement(connection);
  137.       // 设置超时
  138.       setStatementTimeout(statement, transactionTimeout);
  139.       // 设置查询大小，默认不限制
  140.       setFetchSize(statement);
  141.       return statement;
  142.     } catch (SQLException e) {
  143.       closeStatement(statement);
  144.       throw e;
  145.     } catch (Exception e) {
  146.       closeStatement(statement);
  147.       throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
  148.     }
  149.   }
  150.  
  151.   // 调用jdbc connection.prepareStatement(sql), 初始化语句
  152.   @Override
  153.   protected Statement instantiateStatement(Connection connection) throws SQLException {
  154.     String sql = boundSql.getSql();
  155.     if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
  156.       String[] keyColumnNames = mappedStatement.getKeyColumns();
  157.       if (keyColumnNames == null) {
  158.         return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
  159.       } else {
  160.         return connection.prepareStatement(sql, keyColumnNames);
  161.       }
  162.     } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
  163.       return connection.prepareStatement(sql);
  164.     } else {
  165.       return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  166.     }
  167.   }
  168.  
  169.   // PreparedStatementHandler handler.parameterize(stmt);
  170.   @Override
  171.   public void parameterize(Statement statement) throws SQLException {
  172.     parameterHandler.setParameters((PreparedStatement) statement);
  173.   }
  174.  
  175.   // org.apache.ibatis.scripting.defaults.DefaultParameterHandler.setParameters()
  176.   @Override
  177.   public void setParameters(PreparedStatement ps) {
  178.     ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
  179.     List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  180.     if (parameterMappings != null) {
  181.       for (int i = 0; i < parameterMappings.size(); i++) {
  182.         ParameterMapping parameterMapping = parameterMappings.get(i);
  183.         if (parameterMapping.getMode() != ParameterMode.OUT) {
  184.           Object value;
  185.           String propertyName = parameterMapping.getProperty();
  186.           if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
  187.             value = boundSql.getAdditionalParameter(propertyName);
  188.           } else if (parameterObject == null) {
  189.             value = null;
  190.           } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
  191.             value = parameterObject;
  192.           } else {
  193.             MetaObject metaObject = configuration.newMetaObject(parameterObject);
  194.             value = metaObject.getValue(propertyName);
  195.           }
  196.           // TypeHandler 处理参数类型
  197.           TypeHandler typeHandler = parameterMapping.getTypeHandler();
  198.           JdbcType jdbcType = parameterMapping.getJdbcType();
  199.           if (value == null && jdbcType == null) {
  200.             jdbcType = configuration.getJdbcTypeForNull();
  201.           }
  202.           try {
  203.             typeHandler.setParameter(ps, i + 1, value, jdbcType);
  204.           } catch (TypeException e) {
  205.             throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
  206.           } catch (SQLException e) {
  207.             throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
  208.           }
  209.         }
  210.       }
  211.     }
  212.   }
  213.  
  214.   // return handler.<E>query(stmt, resultHandler);
  215.   // org.apache.ibatis.executor.statement.RoutingStatementHandler.query()
  216.   @Override
  217.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  218.     return delegate.<E>query(statement, resultHandler);
  219.   }
  220.  
  221.   // PreparedStatementHandler.query()
  222.   @Override
  223.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  224.     PreparedStatement ps = (PreparedStatement) statement;
  225.     // 调用驱动程序执行 execute
  226.     ps.execute();
  227.     // 处理结果集映射
  228.     return resultSetHandler.<E> handleResultSets(ps);
  229.   }
  230.  
  231.   // org.apache.ibatis.executor.resultset.DefaultResultSetHandler.handleResultSets(), 处理结果集映射
  232.   @Override
  233.   public List<Object> handleResultSets(Statement stmt) throws SQLException {
  234.     ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
  235.  
  236.     final List<Object> multipleResults = new ArrayList<>();
  237.  
  238.     int resultSetCount = 0;
  239.     // 获取第一个结果集（开始偏移的地方）
  240.     ResultSetWrapper rsw = getFirstResultSet(stmt);
  241.  
  242.     List<ResultMap> resultMaps = mappedStatement.getResultMaps();
  243.     int resultMapCount = resultMaps.size();
  244.     validateResultMapsCount(rsw, resultMapCount);
  245.     while (rsw != null && resultMapCount > resultSetCount) {
  246.       ResultMap resultMap = resultMaps.get(resultSetCount);
  247.       handleResultSet(rsw, resultMap, multipleResults, null);
  248.       rsw = getNextResultSet(stmt);
  249.       cleanUpAfterHandlingResultSet();
  250.       resultSetCount++;
  251.     }
  252.  
  253.     String[] resultSets = mappedStatement.getResultSets();
  254.     if (resultSets != null) {
  255.       while (rsw != null && resultSetCount < resultSets.length) {
  256.         ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
  257.         if (parentMapping != null) {
  258.           String nestedResultMapId = parentMapping.getNestedResultMapId();
  259.           ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
  260.           handleResultSet(rsw, resultMap, null, parentMapping);
  261.         }
  262.         rsw = getNextResultSet(stmt);
  263.         cleanUpAfterHandlingResultSet();
  264.         resultSetCount++;
  265.       }
  266.     }
  267.  
  268.     return collapseSingleResultList(multipleResults);
  269.   }
  270.  
  271.   // org.apache.ibatis.executor.resultset.ResultSetWrapper, 根据第一行返回数据集，初始化字段名及字段类型
  272.   public ResultSetWrapper(ResultSet rs, Configuration configuration) throws SQLException {
  273.     super();
  274.     this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
  275.     this.resultSet = rs;
  276.     final ResultSetMetaData metaData = rs.getMetaData();
  277.     final int columnCount = metaData.getColumnCount();
  278.     for (int i = 1; i <= columnCount; i++) {
  279.       columnNames.add(configuration.isUseColumnLabel() ? metaData.getColumnLabel(i) : metaData.getColumnName(i));
  280.       // java.sql.Types, 处理返回的类型为具体的java类型映射到 org.apache.ibatis.type.JdbcType
  281.       jdbcTypes.add(JdbcType.forCode(metaData.getColumnType(i)));
  282.       // java 类型全名
  283.       classNames.add(metaData.getColumnClassName(i));
  284.     }
  285.   }

数据库结果映射到javabean

  1.   // DefaultResultSetHandler.handleResultSet() 处理单条记录映射关系
  2.   private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
  3.     try {
  4.       if (parentMapping != null) {
  5.         handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
  6.       } else {
  7.         if (resultHandler == null) {
  8.           DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
  9.           handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
  10.           multipleResults.add(defaultResultHandler.getResultList());
  11.         } else {
  12.           handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
  13.         }
  14.       }
  15.     } finally {
  16.       // issue #228 (close resultsets)
  17.       closeResultSet(rsw.getResultSet());
  18.     }
  19.   }
  20.   // handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
  21.   public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
  22.     if (resultMap.hasNestedResultMaps()) {
  23.       // 嵌套数据的映射
  24.       ensureNoRowBounds();
  25.       checkResultHandler();
  26.       handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
  27.     } else {
  28.       // 简单数据映射
  29.       handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
  30.     }
  31.   }
  32.   // 简单数据映射
  33.   private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
  34.       throws SQLException {
  35.     DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
  36.     ResultSet resultSet = rsw.getResultSet();
  37.     // 跳过行偏移，难道不是在数据sql中添加 limit 进行数据筛选的？
  38.     skipRows(resultSet, rowBounds);
  39.     while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
  40.       // 1. Discriminated 鉴别器
  41.       ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
  42.       //
  43.       Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
  44.       storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
  45.     }
  46.   }
  47.   // 检测超过 limit 后，不再继续获取结果
  48.   private boolean shouldProcessMoreRows(ResultContext<?> context, RowBounds rowBounds) {
  49.     return !context.isStopped() && context.getResultCount() < rowBounds.getLimit();
  50.   }
  51.   // Discriminated
  52.   public ResultMap resolveDiscriminatedResultMap(ResultSet rs, ResultMap resultMap, String columnPrefix) throws SQLException {
  53.     Set<String> pastDiscriminators = new HashSet<>();
  54.     Discriminator discriminator = resultMap.getDiscriminator();
  55.     while (discriminator != null) {
  56.       final Object value = getDiscriminatorValue(rs, discriminator, columnPrefix);
  57.       final String discriminatedMapId = discriminator.getMapIdFor(String.valueOf(value));
  58.       if (configuration.hasResultMap(discriminatedMapId)) {
  59.         resultMap = configuration.getResultMap(discriminatedMapId);
  60.         Discriminator lastDiscriminator = discriminator;
  61.         discriminator = resultMap.getDiscriminator();
  62.         if (discriminator == lastDiscriminator || !pastDiscriminators.add(discriminatedMapId)) {
  63.           break;
  64.         }
  65.       } else {
  66.         break;
  67.       }
  68.     }
  69.     return resultMap;
  70.   }
  71.  
  72.   // 从结果set中获取值
  73.   private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
  74.     final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  75.     Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
  76.     if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
  77.       final MetaObject metaObject = configuration.newMetaObject(rowValue);
  78.       boolean foundValues = this.useConstructorMappings;
  79.       if (shouldApplyAutomaticMappings(resultMap, false)) {
  80.         foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
  81.       }
  82.       foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
  83.       foundValues = lazyLoader.size() > 0 || foundValues;
  84.       rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
  85.     }
  86.     return rowValue;
  87.   }
  88.  
  89.   // DefaultResultSetHandler
  90.   private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
  91.       throws SQLException {
  92.     final Class<?> resultType = resultMap.getType();
  93.     final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
  94.     final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
  95.     if (hasTypeHandlerForResultObject(rsw, resultType)) {
  96.       return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
  97.     } else if (!constructorMappings.isEmpty()) {
  98.       return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);
  99.     } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {
  100.       return objectFactory.create(resultType);
  101.     } else if (shouldApplyAutomaticMappings(resultMap, false)) {
  102.       return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix);
  103.     }
  104.     throw new ExecutorException("Do not know how to create an instance of " + resultType);
  105.   }
  106.  
  107.   // 构造器注入方式
  108.   private Object createByConstructorSignature(ResultSetWrapper rsw, Class<?> resultType, List<Class<?>> constructorArgTypes, List<Object> constructorArgs,
  109.                                               String columnPrefix) throws SQLException {
  110.     final Constructor<?>[] constructors = resultType.getDeclaredConstructors();
  111.     final Constructor<?> defaultConstructor = findDefaultConstructor(constructors);
  112.     if (defaultConstructor != null) {
  113.       return createUsingConstructor(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix, defaultConstructor);
  114.     } else {
  115.       for (Constructor<?> constructor : constructors) {
  116.         if (allowedConstructorUsingTypeHandlers(constructor, rsw.getJdbcTypes())) {
  117.           return createUsingConstructor(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix, constructor);
  118.         }
  119.       }
  120.     }
  121.     throw new ExecutorException("No constructor found in " + resultType.getName() + " matching " + rsw.getClassNames());
  122.   }
  123.  
  124.   private Object createUsingConstructor(ResultSetWrapper rsw, Class<?> resultType, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix, Constructor<?> constructor) throws SQLException {
  125.     boolean foundValues = false;
  126.     for (int i = 0; i < constructor.getParameterTypes().length; i++) {
  127.       Class<?> parameterType = constructor.getParameterTypes()[i];
  128.       String columnName = rsw.getColumnNames().get(i);
  129.       TypeHandler<?> typeHandler = rsw.getTypeHandler(parameterType, columnName);
  130.       Object value = typeHandler.getResult(rsw.getResultSet(), prependPrefix(columnName, columnPrefix));
  131.       constructorArgTypes.add(parameterType);
  132.       constructorArgs.add(value);
  133.       foundValues = value != null || foundValues;
  134.     }
  135.     // 调用构造方法注入值
  136.     return foundValues ? objectFactory.create(resultType, constructorArgTypes, constructorArgs) : null;
  137.   }
  1.   // org.apache.ibatis.reflection.factory.DefaultObjectFactory.create(), 调用构造器返回 bean 实例
  2.   @SuppressWarnings("unchecked")
  3.   @Override
  4.   public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
  5.     Class<?> classToCreate = resolveInterface(type);
  6.     // we know types are assignable
  7.     return (T) instantiateClass(classToCreate, constructorArgTypes, constructorArgs);
  8.   }
  9.  
  10.   private  <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
  11.     try {
  12.       Constructor<T> constructor;
  13.       if (constructorArgTypes == null || constructorArgs == null) {
  14.         constructor = type.getDeclaredConstructor();
  15.         try {
  16.           return constructor.newInstance();
  17.         } catch (IllegalAccessException e) {
  18.           if (Reflector.canControlMemberAccessible()) {
  19.             constructor.setAccessible(true);
  20.             return constructor.newInstance();
  21.           } else {
  22.             throw e;
  23.           }
  24.         }
  25.       }
  26.       constructor = type.getDeclaredConstructor(constructorArgTypes.toArray(new Class[constructorArgTypes.size()]));
  27.       try {
  28.         return constructor.newInstance(constructorArgs.toArray(new Object[constructorArgs.size()]));
  29.       } catch (IllegalAccessException e) {
  30.         if (Reflector.canControlMemberAccessible()) {
  31.           constructor.setAccessible(true);
  32.           return constructor.newInstance(constructorArgs.toArray(new Object[constructorArgs.size()]));
  33.         } else {
  34.           throw e;
  35.         }
  36.       }
  37.     } catch (Exception e) {
  38.       StringBuilder argTypes = new StringBuilder();
  39.       if (constructorArgTypes != null && !constructorArgTypes.isEmpty()) {
  40.         for (Class<?> argType : constructorArgTypes) {
  41.           argTypes.append(argType.getSimpleName());
  42.           argTypes.append(",");
  43.         }
  44.         argTypes.deleteCharAt(argTypes.length() - 1); // remove trailing ,
  45.       }
  46.       StringBuilder argValues = new StringBuilder();
  47.       if (constructorArgs != null && !constructorArgs.isEmpty()) {
  48.         for (Object argValue : constructorArgs) {
  49.           argValues.append(String.valueOf(argValue));
  50.           argValues.append(",");
  51.         }
  52.         argValues.deleteCharAt(argValues.length() - 1); // remove trailing ,
  53.       }
  54.       throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + e, e);
  55.     }
  56.   }

数据集获取

  1.   // 保存结果
  2.   private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
  3.     if (parentMapping != null) {
  4.       linkToParents(rs, parentMapping, rowValue);
  5.     } else {
  6.       callResultHandler(resultHandler, resultContext, rowValue);
  7.     }
  8.   }
  9.  
  10.   @SuppressWarnings("unchecked" /* because ResultHandler<?> is always ResultHandler<Object>*/)
  11.   private void callResultHandler(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue) {
  12.     resultContext.nextResultObject(rowValue);
  13.     ((ResultHandler<Object>) resultHandler).handleResult(resultContext);
  14.   }
  15.   //
  16.   private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
  17.       throws SQLException {
  18.     final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
  19.     boolean foundValues = false;
  20.     final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
  21.     for (ResultMapping propertyMapping : propertyMappings) {
  22.       String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
  23.       if (propertyMapping.getNestedResultMapId() != null) {
  24.         // the user added a column attribute to a nested result map, ignore it
  25.         column = null;
  26.       }
  27.       if (propertyMapping.isCompositeResult()
  28.           || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
  29.           || propertyMapping.getResultSet() != null) {
  30.         Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
  31.         // issue #541 make property optional
  32.         final String property = propertyMapping.getProperty();
  33.         if (property == null) {
  34.           continue;
  35.         } else if (value == DEFERED) {
  36.           foundValues = true;
  37.           continue;
  38.         }
  39.         if (value != null) {
  40.           foundValues = true;
  41.         }
  42.         if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {
  43.           // gcode issue #377, call setter on nulls (value is not 'found')
  44.           metaObject.setValue(property, value);
  45.         }
  46.       }
  47.     }
  48.     return foundValues;
  49.   }
  50.  
  51.   // collapseSingleResultList(multipleResults);  转换多级 list 为1级list
  52.   @SuppressWarnings("unchecked")
  53.   private List<Object> collapseSingleResultList(List<Object> multipleResults) {
  54.     return multipleResults.size() == 1 ? (List<Object>) multipleResults.get(0) : multipleResults;
  55.   }

至此，一条select 语句搞定！

主要经历几个阶段：
　　1. 加载配置
　　2. 创建sqlSessionFactory
　　3. 获取sqlSession
　　4. jdbc连接
　　5. 获取mapper
　　6. 查询参数绑定
　　7. 获取db结果
　　8. 处理返回集字段映射
　　9. 缓存结果
　　10. 返回结果

简单读！Mybatis源码（一）一条select的一生的更多相关文章

  1. MyBatis源码解读（1）——SqlSessionFactory

    在前面对MyBatis稍微有点了解过后,现在来对MyBatis的源码试着解读一下,并不是解析,暂时定为解读.所有对MyBatis解读均是基于MyBatis-3.4.1,官网中文文档:http://ww ...

  2. Mybatis源码解析-DynamicSqlSource和RawSqlSource的区别

    XMLLanguageDriver是ibatis的默认解析sql节点帮助类,其中的方法其会调用生成DynamicSqlSource和RawSqlSource这两个帮助类,本文将对此作下简单的简析 应用 ...

  3. MyBatis 源码分析 - 映射文件解析过程

    1.简介 在上一篇文章中,我详细分析了 MyBatis 配置文件的解析过程.由于上一篇文章的篇幅比较大,加之映射文件解析过程也比较复杂的原因.所以我将映射文件解析过程的分析内容从上一篇文章中抽取出来, ...

  4. MyBatis源码分析-SQL语句执行的完整流程

    MyBatis 是支持定制化 SQL.存储过程以及高级映射的优秀的持久层框架.MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集.MyBatis 可以对配置和原生Map使用简 ...

  5. MyBatis源码分析（4）—— Cache构建以及应用

    @(MyBatis)[Cache] MyBatis源码分析--Cache构建以及应用 SqlSession使用缓存流程 如果开启了二级缓存,而Executor会使用CachingExecutor来装饰 ...

  6. 读jQuery源码 - Deferred

    Deferred首次出现在jQuery 1.5中,在jQuery 1.8之后被改写,它的出现抹平了javascript中的大量回调产生的金字塔,提供了异步编程的能力,它主要服役于jQuery.ajax ...

  7. 【MyBatis源码分析】select源码分析及小结

    示例代码 之前的文章说过,对于MyBatis来说insert.update.delete是一组的,因为对于MyBatis来说它们都是update:select是一组的,因为对于MyBatis来说它就是 ...

  8. 【MyBatis源码解析】MyBatis一二级缓存

    MyBatis缓存 我们知道,频繁的数据库操作是非常耗费性能的(主要是因为对于DB而言,数据是持久化在磁盘中的,因此查询操作需要通过IO,IO操作速度相比内存操作速度慢了好几个量级),尤其是对于一些相 ...

  9. 跟我一起读postgresql源码(八)——Executor(查询执行模块之——可优化语句的执行)

    2.可优化语句的执行 可优化语句的共同特点是它们被查询编译器处理后都会生成査询计划树,这一类语句由执行器(Executor)处理.该模块对外提供了三个接口: ExecutorStart.Executo ...

  10. 学习笔记02（随便看看mybatis源码）

    两个很有名的持久层hibernate和mybatis应该很熟悉不过了,两者最大相同点是底层都是对jdbc的封装,最大的不同点是前者是自动生成sql语句,后者是需要我们在映射文件中写出sql. 其实从以 ...

随机推荐

  1. Spring Cloud的概述（二）

    1.什么是spring cloud? spring cloud,基于spring boot提供了一套微服务的解决方案,包括服务的注册与发现,配置中心,全链路监控,服务网管,负载均衡,熔断等组件,除了基 ...

  2. github node.js

    #安装githubyum install git -y #下载nvmgit clone git://github.com/creationix/nvm.git ~/nvm #设置nvm 自动运行;ec ...

  3. linux中du与df的区别和联系

    1,两者区别 du,disk usage,是通过搜索文件来计算每个文件的大小然后累加,du能看到的文件只是一些当前存在 的,没有被删除的.他计算的大小就是当前他认为存在的所有文件大小的累加和. df, ...

  4. python11 装饰器与闭包

    一.装饰器定义 本质:一种函数,为其他函数增加新功能 原则: 1.不修改被修饰函数的源代码 2.不修改被修饰函数的调用方式 需要技能:装饰器=高阶函数+函数嵌套+闭包 二.高阶函数 定义:函数接收的参 ...

  5. Laravel 中使用 JWT 认证的 Restful API

    Laravel 中使用 JWT 认证的 Restful API 5天前/  678 /  3 / 更新于 3天前     在此文章中,我们将学习如何使用 JWT 身份验证在 Laravel 中构建 r ...

  6. Java 字符编码（二）Java 中的编解码

    Java 字符编码(二)Java 中的编解码 java.nio.charset 包中提供了一套处理字符编码的工具类,主要有 Charset.CharsetDecoder.CharsetEncoder. ...

  7. eclipse汉化包

    把eclipse英文汉化成中文,首先我们要知道自己安装的eclipse版本,可以在eclipse的安装目录下找到readme用浏览器打开查看版本,或者用记事本打开.eclipseproduct文件,查 ...

  8. mysql too many connection 解决

    最近的项目用了动态切换数据源起初感觉还好,后来发现每次切换数据库都会创建一个新的连接,这样就导致大量的sleep线程.而mysql的默认sleep时间是28800秒....默认最大连接数为151,这就 ...

  9. 让粒子可以在白色背景显示 [Blending Shader 实操]

    Unity3D 提供了粒子特效的各种shader,今天要说的是 Additive(因为项目最初就是用了Additive 发生了问题.. ε=ε=ε=┏(゜ロ゜;)┛) Additive Particl ...

  10. css摘要

    由于需要,今天花三个小时了解一下css,在此记录一些摘要: 参考w3school 1. 当同一个 HTML 元素被不止一个样式定义时,会使用哪个样式呢? 一般而言,所有的样式会根据下面的规则层叠于一个 ...