源码分析 | Mybatis接口没有实现类为什么可以执行增删改查

@Test  
public void test(){  
    B b = new B();  
    b.scan();  //我的输出结果是什么？  
}  
static class A {  
    public void scan(){  
        doScan();  
    }  
    protected void doScan(){  
        System.out.println("A.doScan");  
    }  
} 
static class B extends A {  
    @Override  
    protected void doScan() {  
        System.out.println("B.doScan");  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

itstack-demo-mybatis  
└── src  
    ├── main  
    │   ├── java  
    │   │   └── org.itstack.demo  
    │   │       ├── dao  
    │   │       │    ├── ISchool.java    
    │   │       │    └── IUserDao.java     
    │   │       └── interfaces       
    │   │             ├── School.java    
    │   │            └── User.java  
    │   ├── resources      
    │   │   ├── mapper  
    │   │   │   ├── School_Mapper.xml  
    │   │   │   └── User_Mapper.xml  
    │   │   ├── props      
    │   │   │   └── jdbc.properties  
    │   │   ├── spring  
    │   │   │   ├── mybatis-config-datasource.xml  
    │   │   │   └── spring-config-datasource.xml  
    │   │   ├── logback.xml  
    │   │   ├── mybatis-config.xml  
    │   │   └── spring-config.xml  
    │   └── webapp  
    │       └── WEB-INF  
    └── test  
         └── java  
             └── org.itstack.demo.test  
                 ├── MybatisApiTest.java  
                 └── SpringApiTest.java 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

<dependency>  
    <groupId>org.mybatis</groupId>  
    <artifactId>mybatis</artifactId>  
    <version>3.4.6</version>  
</dependency> 
1.
2.
3.
4.
5.

public class MybatisApiTest {  
    @Test  
    public void test_queryUserInfoById() { 
        String resource = "spring/mybatis-config-datasource.xml";  
        Reader reader;  
        try {  
            reader = Resources.getResourceAsReader(resource);  
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);  
            SqlSession session = sqlMapper.openSession();  
            try { 
                 User user = session.selectOne("org.itstack.demo.dao.IUserDao.queryUserInfoById", 1L);  
                System.out.println(JSON.toJSONString(user));  
            } finally {  
                session.close();  
                reader.close();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

public interface IUserDao {  
     User queryUserInfoById(Long id);  
} 
1.
2.
3.

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
        "http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
    <environments default="development">  
        <environment id="development">  
            <transactionManager type="JDBC"/>  
            <dataSource type="POOLED">  
                <property name="driver" value="com.mysql.jdbc.Driver"/>  
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/itstack?useUnicode=true"/>  
                <property name="username" value="root"/> 
                 <property name="password" value="123456"/>  
            </dataSource>  
        </environment>  
    </environments>  
    <mappers>  
        <mapper resource="mapper/User_Mapper.xml"/>  
    </mappers> 
</configuration> 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

{"age":18,"createTime":1571376957000,"id":1,"name":"花花","updateTime":1571376957000} 
1.

public class SqlSessionFactoryBuilder {  
  public SqlSessionFactory build(Reader reader) {  
    return build(reader, null, null);  
  }  
  public SqlSessionFactory build(Reader reader, String environment) {  
    return build(reader, environment, null);  
  }  
  public SqlSessionFactory build(Reader reader, Properties properties) {  
    return build(reader, null, properties);  
  }  
  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {  
    try {  
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);  
      return build(parser.parse());  
    } catch (Exception e) {  
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);  
    } finally {  
      ErrorContext.instance().reset();  
      try {  
        reader.close();  
      } catch (IOException e) {  
        // Intentionally ignore. Prefer previous error.  
      }  
    }  
  }  
  public SqlSessionFactory build(InputStream inputStream) {  
    return build(inputStream, null, null);  
  }  
  public SqlSessionFactory build(InputStream inputStream, String environment) {  
    return build(inputStream, environment, null);  
  }  
  public SqlSessionFactory build(InputStream inputStream, Properties properties) {  
    return build(inputStream, null, properties);  
  }  
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {  
    try {  
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);  
      return build(parser.parse());  
    } catch (Exception e) {  
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);  
    } finally {  
      ErrorContext.instance().reset();  
      try {  
        inputStream.close();  
      } catch (IOException e) { 
         // Intentionally ignore. Prefer previous error.  
      }  
    }  
  }  
  public SqlSessionFactory build(Configuration config) {  
    return new DefaultSqlSessionFactory(config);  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.

public class XMLConfigBuilder extends BaseBuilder {  
  private boolean parsed;  
  private final XPathParser parser;  
  private String environment;  
  private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();  
  ...  
  public XMLConfigBuilder(Reader reader, String environment, Properties props) {  
    this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);  
  }  
  ...  
}   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

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

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

XMLConfigBuilder.this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);  
    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {  
      super(new Configuration());  
      ErrorContext.instance().resource("SQL Mapper Configuration");  
      this.configuration.setVariables(props);  
      this.parsed = false;  
      this.environment = environment;  
      this.parser = parser;  
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.

public abstract class BaseBuilder {  
      protected final Configuration configuration;  
      protected final TypeAliasRegistry typeAliasRegistry;  
      protected final TypeHandlerRegistry typeHandlerRegistry; 
      public BaseBuilder(Configuration configuration) {  
        this.configuration = configuration;  
        thisthis.typeAliasRegistry = this.configuration.getTypeAliasRegistry();  
        thisthis.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();  
      }  
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

public class XMLConfigBuilder extends BaseBuilder {      
     public Configuration parse() {  
       if (parsed) { 
         throw new BuilderException("Each XMLConfigBuilder can only be used once.");  
       }  
       parsed = true;  
       parseConfiguration(parser.evalNode("/configuration"));  
       return configuration;  
     }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

parseConfiguration(parser.evalNode("/configuration"));  
private void parseConfiguration(XNode root) {  
    try {  
      //issue #117 read properties first  
      //属性解析propertiesElement  
      propertiesElement(root.evalNode("properties"));  
      //加载settings节点settingsAsProperties  
      Properties settings = settingsAsProperties(root.evalNode("settings"));  
      //加载自定义VFS loadCustomVfs  
      loadCustomVfs(settings);  
      //解析类型别名typeAliasesElement  
      typeAliasesElement(root.evalNode("typeAliases"));  
      //加载插件pluginElement  
      pluginElement(root.evalNode("plugins"));  
      //加载对象工厂objectFactoryElement  
      objectFactoryElement(root.evalNode("objectFactory"));  
      //创建对象包装器工厂objectWrapperFactoryElement  
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));  
      //加载反射工厂reflectorFactoryElement  
      reflectorFactoryElement(root.evalNode("reflectorFactory"));  
      //元素设置  
      settingsElement(settings);  
      // read it after objectFactory and objectWrapperFactory issue #631  
      //加载环境配置environmentsElement  
      environmentsElement(root.evalNode("environments"));  
      //数据库厂商标识加载databaseIdProviderElement  
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));  
      //加载类型处理器typeHandlerElement  
      typeHandlerElement(root.evalNode("typeHandlers"));  
      //加载mapper文件mapperElement  
      mapperElement(root.evalNode("mappers"));  
    } catch (Exception e) {  
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);  
    }  
}  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.

<!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)> 
<!ELEMENT databaseIdProvider (property*)>  
<!ATTLIST databaseIdProvider  
type CDATA #REQUIRED  
>  
<!ELEMENT properties (property*)>  
<!ATTLIST properties  
resource CDATA #IMPLIED  
url CDATA #IMPLIED  
>  
<!ELEMENT property EMPTY>  
<!ATTLIST property  
name CDATA #REQUIRED  
value CDATA #REQUIRED  
> 
<!ELEMENT settings (setting+)>  
<!ELEMENT setting EMPTY>  
<!ATTLIST setting  
name CDATA #REQUIRED  
value CDATA #REQUIRED  
>  
<!ELEMENT typeAliases (typeAlias*,package*)> 
<!ELEMENT typeAlias EMPTY>  
<!ATTLIST typeAlias  
type CDATA #REQUIRED  
alias CDATA #IMPLIED  
>  
<!ELEMENT typeHandlers (typeHandler*,package*)>  
<!ELEMENT typeHandler EMPTY>  
<!ATTLIST typeHandler  
javaType CDATA #IMPLIED  
jdbcType CDATA #IMPLIED  
handler CDATA #REQUIRED  
> 
<!ELEMENT objectFactory (property*)>  
<!ATTLIST objectFactory  
type CDATA #REQUIRED  
>  
<!ELEMENT objectWrapperFactory EMPTY>  
<!ATTLIST objectWrapperFactory  
type CDATA #REQUIRED  
>  
<!ELEMENT reflectorFactory EMPTY>  
<!ATTLIST reflectorFactory  
type CDATA #REQUIRED  
> 
<!ELEMENT plugins (plugin+)>  
<!ELEMENT plugin (property*)> 
<!ATTLIST plugin  
interceptor CDATA #REQUIRED  
>  
<!ELEMENT environments (environment+)>  
<!ATTLIST environments  
default CDATA #REQUIRED  
>  
<!ELEMENT environment (transactionManager,dataSource)>  
<!ATTLIST environment  
id CDATA #REQUIRED  
>  
<!ELEMENT transactionManager (property*)>  
<!ATTLIST transactionManager  
type CDATA #REQUIRED  
>  
<!ELEMENT dataSource (property*)>  
<!ATTLIST dataSource  
type CDATA #REQUIRED  
>  
<!ELEMENT mappers (mapper*,package*)>  
<!ELEMENT mapper EMPTY>  
<!ATTLIST mapper  
resource CDATA #IMPLIED  
url CDATA #IMPLIED  
class CDATA #IMPLIED  
>  
<!ELEMENT package EMPTY>  
<!ATTLIST package  
name CDATA #REQUIRED  
> 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.

public class Configuration {  
  protected Environment environment;  
  // 允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。默认为false  
  protected boolean safeRowBoundsEnabled;  
  // 允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为false。 
  protected boolean safeResultHandlerEnabled = true;  
  // 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。默认false  
  protected boolean mapUnderscoreToCamelCase;  
  // 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载。默认值false (true in ≤3.4.1)  
  protected boolean aggressiveLazyLoading;  
  // 是否允许单一语句返回多结果集（需要兼容驱动）。  
  protected boolean multipleResultSetsEnabled = true;  
  // 允许 JDBC 支持自动生成主键，需要驱动兼容。这就是insert时获取mysql自增主键/oracle sequence的开关。注：一般来说,这是希望的结果,应该默认值为true比较合适。  
  protected boolean useGeneratedKeys;  
  // 使用列标签代替列名,一般来说,这是希望的结果  
  protected boolean useColumnLabel = true;  
  // 是否启用缓存 {默认是开启的，可能这也是你的面试题}  
  protected boolean cacheEnabled = true;  
  // 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。  
  protected boolean callSettersOnNulls;  
  // 允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）  
  protected boolean useActualParamName = true;  
  //当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始） 注：这里应该拆分为两个参数比较合适, 一个用于结果集，一个用于单记录。通常来说，我们会希望结果集不是null，单记录仍然是null 
   protected boolean returnInstanceForEmptyRow;  
  // 指定 MyBatis 增加到日志名称的前缀。 
   protected String logPrefix;  
  // 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。一般建议指定为slf4j或log4j  
  protected Class <? extends Log> logImpl;  
   // 指定VFS的实现, VFS是mybatis提供的用于访问AS内资源的一个简便接口  
  protected Class <? extends VFS> vfsImpl; 
   // MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。 
   protected LocalCacheScope localCacheScope = LocalCacheScope.SESSION;  
  // 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。 
   protected JdbcType jdbcTypeForNull = JdbcType.OTHER;  
  // 指定对象的哪个方法触发一次延迟加载。  
  protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" })); 
   // 设置超时时间，它决定驱动等待数据库响应的秒数。默认不超时  
  protected Integer defaultStatementTimeout;  
  // 为驱动的结果集设置默认获取数量。  
  protected Integer defaultFetchSize;  
  // SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。  
  protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE;  
  // 指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。 
   protected AutoMappingBehavior autoMappingBehavior = AutoMappingBehavior.PARTIAL;  
  // 指定发现自动映射目标未知列（或者未知属性类型）的行为。这个值应该设置为WARNING比较合适  
  protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior = AutoMappingUnknownColumnBehavior.NONE;  
  // settings下的properties属性  
  protected Properties variables = new Properties();  
  // 默认的反射器工厂,用于操作属性、构造器方便 
   protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();  
  // 对象工厂, 所有的类resultMap类都需要依赖于对象工厂来实例化  
  protected ObjectFactory objectFactory = new DefaultObjectFactory();  
  // 对象包装器工厂,主要用来在创建非原生对象,比如增加了某些监控或者特殊属性的代理类  
  protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();  
  // 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。  
  protected boolean lazyLoadingEnabled = false;  
  // 指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。MyBatis 3.3+使用JAVASSIST  
  protected ProxyFactory proxyFactory = new JavassistProxyFactory(); // #224 Using internal Javassist instead of OGNL  
  // MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。  
  protected String databaseId;  
  ...  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.

protected static class StrictMap<V> extends HashMap<String, V> {  
    private static final long serialVersionUID = -4950446264854982944L;  
    private final String name;  
    public StrictMap(String name, int initialCapacity, float loadFactor) {  
      super(initialCapacity, loadFactor);  
      this.name = name;  
    }  
    public StrictMap(String name, int initialCapacity) {  
      super(initialCapacity);  
      this.name = name;  
    }  
    public StrictMap(String name) {  
      super();  
      this.name = name;  
    }  
    public StrictMap(String name, Map<String, ? extends V> m) {  
      super(m);  
      this.name = name;  
    }  
}     
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

private void mapperElement(XNode parent) throws Exception {  
   if (parent != null) {  
     for (XNode child : parent.getChildren()) {  
       // 如果要同时使用package自动扫描和通过mapper明确指定要加载的mapper，一定要确保package自动扫描的范围不包含明确指定的mapper，否则在通过package扫描的interface的时候，尝试加载对应xml文件的loadXmlResource()的逻辑中出现判重出错，报org.apache.ibatis.binding.BindingException异常，即使xml文件中包含的内容和mapper接口中包含的语句不重复也会出错，包括加载mapper接口时自动加载的xml mapper也一样会出错。 
        if ("package".equals(child.getName())) {  
         String mapperPackage = child.getStringAttribute("name");  
         configuration.addMappers(mapperPackage);  
       } else {  
         String resource = child.getStringAttribute("resource");  
         String url = child.getStringAttribute("url");  
         String mapperClass = child.getStringAttribute("class");  
         if (resource != null && url == null && mapperClass == null) {  
           ErrorContext.instance().resource(resource);  
           InputStream inputStream = Resources.getResourceAsStream(resource);  
           XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());  
           mapperParser.parse();  
         } else if (resource == null && url != null && mapperClass == null) {  
           ErrorContext.instance().resource(url);  
           InputStream inputStream = Resources.getUrlAsStream(url);  
           XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());  
           mapperParser.parse();  
         } else if (resource == null && url == null && mapperClass != null) {  
           Class<?> mapperInterface = Resources.classForName(mapperClass);  
           configuration.addMapper(mapperInterface);  
         } else {  
           throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");  
         }  
       }  
     }  
   }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

<mappers>  
     <package name="org.itstack.demo"/>  
   </mappers> 
1.
2.
3.

<mappers>  
       <mapper resource="mapper/User_Mapper.xml"/>  
       <mapper class=""/>  
       <mapper url=""/>  
   </mappers> 
1.
2.
3.
4.
5.

private void mapperElement(XNode parent) throws Exception {  
  if (parent != null) {  
    for (XNode child : parent.getChildren()) {  
      if ("package".equals(child.getName())) {  
        String mapperPackage = child.getStringAttribute("name");  
        configuration.addMappers(mapperPackage);  
      } else {  
        ...  
      }  
    }  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

public void addMappers(String packageName, Class<?> superType) {  
  // mybatis框架提供的搜索classpath下指定package以及子package中符合条件(注解或者继承于某个类/接口)的类，默认使用Thread.currentThread().getContextClassLoader()返回的加载器,和spring的工具类殊途同归。 
   ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();     
  // 无条件的加载所有的类,因为调用方传递了Object.class作为父类,这也给以后的指定mapper接口预留了余地  
  resolverUtil.find(new ResolverUtil.IsA(superType), packageName);   
 // 所有匹配的calss都被存储在ResolverUtil.matches字段中  
  Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();  
  for (Class<?> mapperClass : mapperSet) {     
    //调用addMapper方法进行具体的mapper类/接口解析  
    addMapper(mapperClass);  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

public <T> void addMapper(Class<T> type) {      
  // 对于mybatis mapper接口文件，必须是interface，不能是class  
  if (type.isInterface()) { 
     if (hasMapper(type)) {  
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");  
    }  
    boolean loadCompleted = false;  
    try {        
      // 为mapper接口创建一个MapperProxyFactory代理  
      knownMappers.put(type, new MapperProxyFactory<T>(type));  
      // It's important that the type is added before the parser is run  
      // otherwise the binding may automatically be attempted by the  
      // mapper parser. If the type is already known, it won't try.  
      MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);  
      parser.parse();  
      loadCompleted = true;  
    } finally {  
      if (!loadCompleted) {  
        knownMappers.remove(type);  
      }  
    }  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>(); 
1.

public class MapperProxyFactory<T> {  
  private final Class<T> mapperInterface;  
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();  
  public MapperProxyFactory(Class<T> mapperInterface) {  
    this.mapperInterface = mapperInterface;  
  }  
  public Class<T> getMapperInterface() {  
    return mapperInterface;  
  }  
  public Map<Method, MapperMethod> getMethodCache() {  
    return methodCache;  
  }  
  @SuppressWarnings("unchecked")  
  protected T newInstance(MapperProxy<T> mapperProxy) {  
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);  
  }  
  public T newInstance(SqlSession sqlSession) {  
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);  
    return newInstance(mapperProxy);  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

<dependency>  
    <groupId>org.mybatis</groupId>  
    <artifactId>mybatis-spring</artifactId>  
    <version>1.3.2</version>  
</dependency> 
1.
2.
3.
4.
5.

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration("classpath:spring-config.xml")  
public class SpringApiTest { 
    private Logger logger = LoggerFactory.getLogger(SpringApiTest.class);  
    @Resource  
    private ISchoolDao schoolDao;  
    @Resource  
    private IUserDao userDao;  
    @Test  
    public void test_queryRuleTreeByTreeId(){  
        School ruleTree = schoolDao.querySchoolInfoById(1L); 
         logger.info(JSON.toJSONString(ruleTree));  
        User user = userDao.queryUserInfoById(1L);  
        logger.info(JSON.toJSONString(user));  
    }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
        http://www.springframework.org/schema/beans/spring-beans.xsd"> 
    <!-- 1.数据库连接池： DriverManagerDataSource 也可以使用DBCP2-->  
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
        <property name="driverClassName" value="${db.jdbc.driverClassName}"/>  
        <property name="url" value="${db.jdbc.url}"/>  
        <property name="username" value="${db.jdbc.username}"/>  
        <property name="password" value="${db.jdbc.password}"/>  
    </bean>  
    <!-- 2.配置SqlSessionFactory对象 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <!-- 注入数据库连接池 -->  
        <property name="dataSource" ref="dataSource"/>  
        <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->  
        <property name="configLocation" value="classpath:mybatis-config.xml"/>  
        <!-- 扫描entity包 使用别名 -->  
        <property name="typeAliasesPackage" value="org.itstack.demo.po"/>  
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->  
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>  
    </bean>  
    <!-- 3.配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <!-- 注入sqlSessionFactory -->  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>  
        <!-- 给出需要扫描Dao接口包，多个逗号隔开 -->  
        <property name="basePackage" value="org.itstack.demo.dao"/>  
    </bean>            
</beans> 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

{"address":"北京市海淀区颐和园路5号","createTime":1571376957000,"id":1,"name":"北京大学","updateTime":1571376957000}  
{"age":18,"createTime":1571376957000,"id":1,"name":"花花","updateTime":1571376957000} 
1.
2.

@Override  
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {  
  if (this.processPropertyPlaceHolders) {  
    processPropertyPlaceHolders();  
  }  
  ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);  
  scanner.setAddToConfig(this.addToConfig);  
  scanner.setAnnotationClass(this.annotationClass);  
  scanner.setMarkerInterface(this.markerInterface);  
  scanner.setSqlSessionFactory(this.sqlSessionFactory);  
  scanner.setSqlSessionTemplate(this.sqlSessionTemplate);  
  scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);  
  scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);  
  scanner.setResourceLoader(this.applicationContext);  
  scanner.setBeanNameGenerator(this.nameGenerator);  
  scanner.registerFilters();  
  scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

@Override  
public Set<BeanDefinitionHolder> doScan(String... basePackages) {  
  Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);  
  if (beanDefinitions.isEmpty()) {  
    logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");  
  } else {  
    processBeanDefinitions(beanDefinitions);  
  }  
  return beanDefinitions;  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {  
    Assert.notEmpty(basePackages, "At least one base package must be specified");  
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();  
    for (String basePackage : basePackages) {  
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);  
        for (BeanDefinition candidate : candidates) { 
             ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);  
            candidate.setScope(scopeMetadata.getScopeName());  
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);  
            if (candidate instanceof AbstractBeanDefinition) {  
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);  
            }  
            if (candidate instanceof AnnotatedBeanDefinition) {  
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)  
            }  
            if (checkCandidate(beanName, candidate)) {  
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);  
                definitionHolder =  
                        AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.regi  
                beanDefinitions.add(definitionHolder);  
                registerBeanDefinition(definitionHolder, this.registry);  
            }  
        }  
    }  
    return beanDefinitions;  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

**processBeanDefinitions(beanDefinitions);**  
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {  
  GenericBeanDefinition definition;  
  for (BeanDefinitionHolder holder : beanDefinitions) {  
    definition = (GenericBeanDefinition) holder.getBeanDefinition();  
    if (logger.isDebugEnabled()) {  
      logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()   
        + "' and '" + definition.getBeanClassName() + "' mapperInterface");  
    }  
    // the mapper interface is the original class of the bean  
    // but, the actual class of the bean is MapperFactoryBean  
    definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59  
    definition.setBeanClass(this.mapperFactoryBean.getClass());  
    definition.getPropertyValues().add("addToConfig", this.addToConfig);  
    boolean explicitFactoryUsed = false;  
    if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {  
      definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));  
      explicitFactoryUsed = true;  
    } else if (this.sqlSessionFactory != null) { 
       definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);  
      explicitFactoryUsed = true;  
    }  
    if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {  
      if (explicitFactoryUsed) {  
        logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");  
      }  
      definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));  
      explicitFactoryUsed = true;  
    } else if (this.sqlSessionTemplate != null) {  
      if (explicitFactoryUsed) {  
        logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");  
      }  
      definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);  
      explicitFactoryUsed = true;  
    }  
    if (!explicitFactoryUsed) {  
      if (logger.isDebugEnabled()) {  
        logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");  
      }  
      definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);  
    }  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {  
  private Class<T> mapperInterface;  
  private boolean addToConfig = true;  
  public MapperFactoryBean() {  
    //intentionally empty   
  }  
  public MapperFactoryBean(Class<T> mapperInterface) {  
    this.mapperInterface = mapperInterface;  
  }  
  /**    
   * 当SpringBean容器初始化时候会调用到checkDaoConfig()，他是继承类中的抽象方法  
   * {@inheritDoc}  
   */  
  @Override  
  protected void checkDaoConfig() {  
    super.checkDaoConfig();  
    notNull(this.mapperInterface, "Property 'mapperInterface' is required"); 
    Configuration configuration = getSqlSession().getConfiguration();  
    if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {  
      try {  
        configuration.addMapper(this.mapperInterface);  
      } catch (Exception e) {  
        logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);  
        throw new IllegalArgumentException(e);  
      } finally {  
        ErrorContext.instance().reset();  
      }  
    }  
  } 
  /**  
   * {@inheritDoc}  
   */  
  @Override  
  public T getObject() throws Exception {  
    return getSqlSession().getMapper(this.mapperInterface);  
  }  
  ... 
 } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {  
       final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);  
       if (mapperProxyFactory == null) {  
         throw new BindingException("Type " + type + " is not known to the MapperRegistry.");  
       }  
       try {  
         return mapperProxyFactory.newInstance(sqlSession);  
       } catch (Exception e) {  
         throw new BindingException("Error getting mapper instance. Cause: " + e, e);  
       }  
     } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

@SuppressWarnings("unchecked")  
        protected T newInstance(MapperProxy<T> mapperProxy) {  
          return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);  
        }  
        public T newInstance(SqlSession sqlSession) {  
          final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);  
          return newInstance(mapperProxy);  
        } 
1.
2.
3.
4.
5.
6.
7.
8.

public class MapperProxy<T> implements InvocationHandler, Serializable {  
  private static final long serialVersionUID = -6424540398559729838L;  
  private final SqlSession sqlSession;  
  private final Class<T> mapperInterface;  
  private final Map<Method, MapperMethod> methodCache;  
  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {  
    this.sqlSession = sqlSession;  
    this.mapperInterface = mapperInterface;  
    this.methodCache = methodCache;  
  }  
  @Override  
  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);  
  }  
  private MapperMethod cachedMapperMethod(Method method) {  
    MapperMethod mapperMethod = methodCache.get(method);  
    if (mapperMethod == null) {  
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());  
      methodCache.put(method, mapperMethod);  
    }  
    return mapperMethod;  
  }  
  @UsesJava7  
  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)  
      throws Throwable {  
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class  
        .getDeclaredConstructor(Class.class, int.class);  
    if (!constructor.isAccessible()) {  
      constructor.setAccessible(true);  
    }  
    final Class<?> declaringClass = method.getDeclaringClass();  
    return constructor  
        .newInstance(declaringClass,  
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED  
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)  
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);  
  }  
  ...  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

public Object execute(SqlSession sqlSession, Object[] args) {  
   Object result;  
   switch (command.getType()) {  
     case INSERT: {  
     Object param = method.convertArgsToSqlCommandParam(args);  
       result = rowCountResult(sqlSession.insert(command.getName(), param));  
       break;  
     }  
     case UPDATE: {  
       Object param = method.convertArgsToSqlCommandParam(args);  
       result = rowCountResult(sqlSession.update(command.getName(), param));  
       break;  
     }  
     case DELETE: {  
       Object param = method.convertArgsToSqlCommandParam(args);  
       result = rowCountResult(sqlSession.delete(command.getName(), param));  
       break;  
     }  
     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;  
     case FLUSH:  
       result = sqlSession.flushStatements();  
       break;  
     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;  
 }   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.

public void afterPropertiesSet() throws Exception {  
  notNull(dataSource, "Property 'dataSource' is required");  
  notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");  
  state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),  
            "Property 'configuration' and 'configLocation' can not specified with together");  
  this.sqlSessionFactory = buildSqlSessionFactory();  
} 
1.
2.
3.
4.
5.
6.
7.

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {  
  Configuration configuration;  
  XMLConfigBuilder xmlConfigBuilder = null;  
  ... 
  if (!isEmpty(this.mapperLocations)) {  
    for (Resource mapperLocation : this.mapperLocations) { 
      if (mapperLocation == null) {  
        continue;  
      }  
      try {  
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),  
            configuration, mapperLocation.toString(), configuration.getSqlFragments());  
        xmlMapperBuilder.parse();  
      } catch (Exception e) {  
        throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);  
      } finally {  
        ErrorContext.instance().reset();  
      }  
      if (LOGGER.isDebugEnabled()) {  
        LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");  
      }  
    }  
  } else {  
    if (LOGGER.isDebugEnabled()) {  
      LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");  
    }  
  }  
  return this.sqlSessionFactoryBuilder.build(configuration);  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

public class XMLMapperBuilder extends BaseBuilder {  
   private final XPathParser parser;  
   private final MapperBuilderAssistant builderAssistant;  
   private final Map<String, XNode> sqlFragments;  
   private final String resource;  
   private void bindMapperForNamespace() { 
      String namespace = builderAssistant.getCurrentNamespace(); 
     if (namespace != null) {  
       Class<?> boundType = null;  
       try {  
         boundType = Resources.classForName(namespace);  
       } catch (ClassNotFoundException e) {  
         //ignore, bound type is not required  
       }  
       if (boundType != null) {  
         if (!configuration.hasMapper(boundType)) {  
           // Spring may not know the real resource name so we set a flag  
           // to prevent loading again this resource from the mapper interface  
           // look at MapperAnnotationBuilder#loadXmlResource  
           configuration.addLoadedResource("namespace:" + namespace);  
           configuration.addMapper(boundType);  
         }  
       }  
     }  
   }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

public class MapperRegistry {  
  public <T> void addMapper(Class<T> type) {  
    if (type.isInterface()) {  
      if (hasMapper(type)) {  
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");  
      }  
      boolean loadCompleted = false;  
      try {  
        knownMappers.put(type, new MapperProxyFactory<T>(type));  
        // It's important that the type is added before the parser is run  
        // otherwise the binding may automatically be attempted by the  
        // mapper parser. If the type is already known, it won't try.  
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);  
        parser.parse();  
        loadCompleted = true;  
      } finally {  
        if (!loadCompleted) {  
          knownMappers.remove(type);  
        }  
      }  
    }  
  }  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

@Resource  
  private ISchoolDao schoolDao; 
  schoolDao.querySchoolInfoById(1L); 
1.
2.
3.