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

@Testpublic 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");    }}

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

<dependency>    <groupId>org.mybatis</groupId>    <artifactId>mybatis</artifactId>    <version>3.4.6</version></dependency>

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();        }    }
}

public interface IUserDao {
     User queryUserInfoById(Long id);
}

<?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>

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

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);  }
}

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);  }  ...}  

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;  }
}

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);  }  }    

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);    }} 

<!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)> <!ELEMENT databaseIdProvider (property*)><!ATTLIST databaseIdProvidertype CDATA #REQUIRED> <!ELEMENT properties (property*)><!ATTLIST propertiesresource CDATA #IMPLIEDurl CDATA #IMPLIED> <!ELEMENT property EMPTY><!ATTLIST propertyname CDATA #REQUIREDvalue CDATA #REQUIRED> <!ELEMENT settings (setting+)> <!ELEMENT setting EMPTY><!ATTLIST settingname CDATA #REQUIREDvalue CDATA #REQUIRED> <!ELEMENT typeAliases (typeAlias*,package*)> <!ELEMENT typeAlias EMPTY><!ATTLIST typeAliastype CDATA #REQUIREDalias CDATA #IMPLIED> <!ELEMENT typeHandlers (typeHandler*,package*)> <!ELEMENT typeHandler EMPTY><!ATTLIST typeHandlerjavaType CDATA #IMPLIEDjdbcType CDATA #IMPLIEDhandler CDATA #REQUIRED> <!ELEMENT objectFactory (property*)><!ATTLIST objectFactorytype CDATA #REQUIRED> <!ELEMENT objectWrapperFactory EMPTY><!ATTLIST objectWrapperFactorytype CDATA #REQUIRED> <!ELEMENT reflectorFactory EMPTY><!ATTLIST reflectorFactorytype CDATA #REQUIRED> <!ELEMENT plugins (plugin+)> <!ELEMENT plugin (property*)><!ATTLIST plugininterceptor CDATA #REQUIRED> <!ELEMENT environments (environment+)><!ATTLIST environmentsdefault CDATA #REQUIRED> <!ELEMENT environment (transactionManager,dataSource)><!ATTLIST environmentid CDATA #REQUIRED> <!ELEMENT transactionManager (property*)><!ATTLIST transactionManagertype CDATA #REQUIRED> <!ELEMENT dataSource (property*)><!ATTLIST dataSourcetype CDATA #REQUIRED> <!ELEMENT mappers (mapper*,package*)> <!ELEMENT mapper EMPTY><!ATTLIST mapperresource CDATA #IMPLIEDurl CDATA #IMPLIEDclass CDATA #IMPLIED> <!ELEMENT package EMPTY><!ATTLIST packagename CDATA #REQUIRED>

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;  ...}

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;    }}    

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.");         }       }     }   }}

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 {        ...      }    }  }}

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);  }}

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);      }    }  }}

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

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);  }}

<dependency>    <groupId>org.mybatis</groupId>    <artifactId>mybatis-spring</artifactId>    <version>1.3.2</version></dependency>

@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));    }
}

<?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>

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

@Overridepublic 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));}

@Overridepublic 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;}

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;}

**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);    }  }}

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);  }
  ...}

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);  }
  ...}

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();}

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);}

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);         }       }     }   }}

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);        }      }    }  }  }